YES(O(1),O(n^2))

We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^2)).

Strict Trs:
  { #equal(@x, @y) -> #eq(@x, @y)
  , appendreverse(@toreverse, @sofar) ->
    appendreverse#1(@toreverse, @sofar)
  , appendreverse#1(::(@a, @as), @sofar) ->
    appendreverse(@as, ::(@a, @sofar))
  , appendreverse#1(nil(), @sofar) -> @sofar
  , bfs(@queue, @futurequeue, @x) -> bfs#1(@queue, @futurequeue, @x)
  , bfs#1(::(@t, @ts), @futurequeue, @x) ->
    bfs#3(@t, @futurequeue, @ts, @x)
  , bfs#1(nil(), @futurequeue, @x) -> bfs#2(@futurequeue, @x)
  , bfs#3(leaf(), @futurequeue, @ts, @x) ->
    bfs(@ts, @futurequeue, @x)
  , bfs#3(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
    bfs#4(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y)
  , bfs#2(::(@t, @ts), @x) -> bfs(reverse(::(@t, @ts)), nil(), @x)
  , bfs#2(nil(), @x) -> leaf()
  , reverse(@xs) -> appendreverse(@xs, nil())
  , bfs#4(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
    bfs(@ts, ::(@t2, ::(@t1, @futurequeue)), @x)
  , bfs#4(#true(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
    node(@y, @t1, @t2)
  , bfs2(@t, @x) -> bfs2#1(dobfs(@t, @x), @x)
  , dobfs(@t, @x) -> bfs(::(@t, nil()), nil(), @x)
  , bfs2#1(@t', @x) -> dobfs(@t', @x)
  , dfs(@queue, @x) -> dfs#1(@queue, @x)
  , dfs#1(::(@t, @ts), @x) -> dfs#2(@t, @t, @ts, @x)
  , dfs#1(nil(), @x) -> leaf()
  , dfs#2(leaf(), @t, @ts, @x) -> dfs(@ts, @x)
  , dfs#2(node(@a, @t1, @t2), @t, @ts, @x) ->
    dfs#3(#equal(@a, @x), @t, @t1, @t2, @ts, @x)
  , dfs#3(#false(), @t, @t1, @t2, @ts, @x) ->
    dfs(::(@t1, ::(@t2, @ts)), @x)
  , dfs#3(#true(), @t, @t1, @t2, @ts, @x) -> @t
  , dodfs(@t, @x) -> dfs(::(@t, nil()), @x) }
Weak Trs:
  { #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
    #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
  , #eq(::(@x_1, @x_2), nil()) -> #false()
  , #eq(::(@x_1, @x_2), leaf()) -> #false()
  , #eq(::(@x_1, @x_2), node(@y_1, @y_2, @y_3)) -> #false()
  , #eq(nil(), ::(@y_1, @y_2)) -> #false()
  , #eq(nil(), nil()) -> #true()
  , #eq(nil(), leaf()) -> #false()
  , #eq(nil(), node(@y_1, @y_2, @y_3)) -> #false()
  , #eq(leaf(), ::(@y_1, @y_2)) -> #false()
  , #eq(leaf(), nil()) -> #false()
  , #eq(leaf(), leaf()) -> #true()
  , #eq(leaf(), node(@y_1, @y_2, @y_3)) -> #false()
  , #eq(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2)) -> #false()
  , #eq(node(@x_1, @x_2, @x_3), nil()) -> #false()
  , #eq(node(@x_1, @x_2, @x_3), leaf()) -> #false()
  , #eq(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) ->
    #and(#eq(@x_1, @y_1), #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3)))
  , #eq(#0(), #0()) -> #true()
  , #eq(#0(), #neg(@y)) -> #false()
  , #eq(#0(), #pos(@y)) -> #false()
  , #eq(#0(), #s(@y)) -> #false()
  , #eq(#neg(@x), #0()) -> #false()
  , #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
  , #eq(#neg(@x), #pos(@y)) -> #false()
  , #eq(#pos(@x), #0()) -> #false()
  , #eq(#pos(@x), #neg(@y)) -> #false()
  , #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
  , #eq(#s(@x), #0()) -> #false()
  , #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
  , #and(#false(), #false()) -> #false()
  , #and(#false(), #true()) -> #false()
  , #and(#true(), #false()) -> #false()
  , #and(#true(), #true()) -> #true() }
Obligation:
  innermost runtime complexity
Answer:
  YES(O(1),O(n^2))

We add following dependency tuples:

Strict DPs:
  { #equal^#(@x, @y) -> c_1(#eq^#(@x, @y))
  , appendreverse^#(@toreverse, @sofar) ->
    c_2(appendreverse#1^#(@toreverse, @sofar))
  , appendreverse#1^#(::(@a, @as), @sofar) ->
    c_3(appendreverse^#(@as, ::(@a, @sofar)))
  , appendreverse#1^#(nil(), @sofar) -> c_4()
  , bfs^#(@queue, @futurequeue, @x) ->
    c_5(bfs#1^#(@queue, @futurequeue, @x))
  , bfs#1^#(::(@t, @ts), @futurequeue, @x) ->
    c_6(bfs#3^#(@t, @futurequeue, @ts, @x))
  , bfs#1^#(nil(), @futurequeue, @x) ->
    c_7(bfs#2^#(@futurequeue, @x))
  , bfs#3^#(leaf(), @futurequeue, @ts, @x) ->
    c_8(bfs^#(@ts, @futurequeue, @x))
  , bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
    c_9(bfs#4^#(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y),
        #equal^#(@x, @y))
  , bfs#2^#(::(@t, @ts), @x) ->
    c_10(bfs^#(reverse(::(@t, @ts)), nil(), @x),
         reverse^#(::(@t, @ts)))
  , bfs#2^#(nil(), @x) -> c_11()
  , bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
    c_13(bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x))
  , bfs#4^#(#true(), @futurequeue, @t1, @t2, @ts, @x, @y) -> c_14()
  , reverse^#(@xs) -> c_12(appendreverse^#(@xs, nil()))
  , bfs2^#(@t, @x) ->
    c_15(bfs2#1^#(dobfs(@t, @x), @x), dobfs^#(@t, @x))
  , bfs2#1^#(@t', @x) -> c_17(dobfs^#(@t', @x))
  , dobfs^#(@t, @x) -> c_16(bfs^#(::(@t, nil()), nil(), @x))
  , dfs^#(@queue, @x) -> c_18(dfs#1^#(@queue, @x))
  , dfs#1^#(::(@t, @ts), @x) -> c_19(dfs#2^#(@t, @t, @ts, @x))
  , dfs#1^#(nil(), @x) -> c_20()
  , dfs#2^#(leaf(), @t, @ts, @x) -> c_21(dfs^#(@ts, @x))
  , dfs#2^#(node(@a, @t1, @t2), @t, @ts, @x) ->
    c_22(dfs#3^#(#equal(@a, @x), @t, @t1, @t2, @ts, @x),
         #equal^#(@a, @x))
  , dfs#3^#(#false(), @t, @t1, @t2, @ts, @x) ->
    c_23(dfs^#(::(@t1, ::(@t2, @ts)), @x))
  , dfs#3^#(#true(), @t, @t1, @t2, @ts, @x) -> c_24()
  , dodfs^#(@t, @x) -> c_25(dfs^#(::(@t, nil()), @x)) }
Weak DPs:
  { #eq^#(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
    c_26(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)),
         #eq^#(@x_1, @y_1),
         #eq^#(@x_2, @y_2))
  , #eq^#(::(@x_1, @x_2), nil()) -> c_27()
  , #eq^#(::(@x_1, @x_2), leaf()) -> c_28()
  , #eq^#(::(@x_1, @x_2), node(@y_1, @y_2, @y_3)) -> c_29()
  , #eq^#(nil(), ::(@y_1, @y_2)) -> c_30()
  , #eq^#(nil(), nil()) -> c_31()
  , #eq^#(nil(), leaf()) -> c_32()
  , #eq^#(nil(), node(@y_1, @y_2, @y_3)) -> c_33()
  , #eq^#(leaf(), ::(@y_1, @y_2)) -> c_34()
  , #eq^#(leaf(), nil()) -> c_35()
  , #eq^#(leaf(), leaf()) -> c_36()
  , #eq^#(leaf(), node(@y_1, @y_2, @y_3)) -> c_37()
  , #eq^#(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2)) -> c_38()
  , #eq^#(node(@x_1, @x_2, @x_3), nil()) -> c_39()
  , #eq^#(node(@x_1, @x_2, @x_3), leaf()) -> c_40()
  , #eq^#(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) ->
    c_41(#and^#(#eq(@x_1, @y_1),
                #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3))),
         #eq^#(@x_1, @y_1),
         #and^#(#eq(@x_2, @y_2), #eq(@x_3, @y_3)),
         #eq^#(@x_2, @y_2),
         #eq^#(@x_3, @y_3))
  , #eq^#(#0(), #0()) -> c_42()
  , #eq^#(#0(), #neg(@y)) -> c_43()
  , #eq^#(#0(), #pos(@y)) -> c_44()
  , #eq^#(#0(), #s(@y)) -> c_45()
  , #eq^#(#neg(@x), #0()) -> c_46()
  , #eq^#(#neg(@x), #neg(@y)) -> c_47(#eq^#(@x, @y))
  , #eq^#(#neg(@x), #pos(@y)) -> c_48()
  , #eq^#(#pos(@x), #0()) -> c_49()
  , #eq^#(#pos(@x), #neg(@y)) -> c_50()
  , #eq^#(#pos(@x), #pos(@y)) -> c_51(#eq^#(@x, @y))
  , #eq^#(#s(@x), #0()) -> c_52()
  , #eq^#(#s(@x), #s(@y)) -> c_53(#eq^#(@x, @y))
  , #and^#(#false(), #false()) -> c_54()
  , #and^#(#false(), #true()) -> c_55()
  , #and^#(#true(), #false()) -> c_56()
  , #and^#(#true(), #true()) -> c_57() }

and mark the set of starting terms.

We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^2)).

Strict DPs:
  { #equal^#(@x, @y) -> c_1(#eq^#(@x, @y))
  , appendreverse^#(@toreverse, @sofar) ->
    c_2(appendreverse#1^#(@toreverse, @sofar))
  , appendreverse#1^#(::(@a, @as), @sofar) ->
    c_3(appendreverse^#(@as, ::(@a, @sofar)))
  , appendreverse#1^#(nil(), @sofar) -> c_4()
  , bfs^#(@queue, @futurequeue, @x) ->
    c_5(bfs#1^#(@queue, @futurequeue, @x))
  , bfs#1^#(::(@t, @ts), @futurequeue, @x) ->
    c_6(bfs#3^#(@t, @futurequeue, @ts, @x))
  , bfs#1^#(nil(), @futurequeue, @x) ->
    c_7(bfs#2^#(@futurequeue, @x))
  , bfs#3^#(leaf(), @futurequeue, @ts, @x) ->
    c_8(bfs^#(@ts, @futurequeue, @x))
  , bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
    c_9(bfs#4^#(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y),
        #equal^#(@x, @y))
  , bfs#2^#(::(@t, @ts), @x) ->
    c_10(bfs^#(reverse(::(@t, @ts)), nil(), @x),
         reverse^#(::(@t, @ts)))
  , bfs#2^#(nil(), @x) -> c_11()
  , bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
    c_13(bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x))
  , bfs#4^#(#true(), @futurequeue, @t1, @t2, @ts, @x, @y) -> c_14()
  , reverse^#(@xs) -> c_12(appendreverse^#(@xs, nil()))
  , bfs2^#(@t, @x) ->
    c_15(bfs2#1^#(dobfs(@t, @x), @x), dobfs^#(@t, @x))
  , bfs2#1^#(@t', @x) -> c_17(dobfs^#(@t', @x))
  , dobfs^#(@t, @x) -> c_16(bfs^#(::(@t, nil()), nil(), @x))
  , dfs^#(@queue, @x) -> c_18(dfs#1^#(@queue, @x))
  , dfs#1^#(::(@t, @ts), @x) -> c_19(dfs#2^#(@t, @t, @ts, @x))
  , dfs#1^#(nil(), @x) -> c_20()
  , dfs#2^#(leaf(), @t, @ts, @x) -> c_21(dfs^#(@ts, @x))
  , dfs#2^#(node(@a, @t1, @t2), @t, @ts, @x) ->
    c_22(dfs#3^#(#equal(@a, @x), @t, @t1, @t2, @ts, @x),
         #equal^#(@a, @x))
  , dfs#3^#(#false(), @t, @t1, @t2, @ts, @x) ->
    c_23(dfs^#(::(@t1, ::(@t2, @ts)), @x))
  , dfs#3^#(#true(), @t, @t1, @t2, @ts, @x) -> c_24()
  , dodfs^#(@t, @x) -> c_25(dfs^#(::(@t, nil()), @x)) }
Weak DPs:
  { #eq^#(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
    c_26(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)),
         #eq^#(@x_1, @y_1),
         #eq^#(@x_2, @y_2))
  , #eq^#(::(@x_1, @x_2), nil()) -> c_27()
  , #eq^#(::(@x_1, @x_2), leaf()) -> c_28()
  , #eq^#(::(@x_1, @x_2), node(@y_1, @y_2, @y_3)) -> c_29()
  , #eq^#(nil(), ::(@y_1, @y_2)) -> c_30()
  , #eq^#(nil(), nil()) -> c_31()
  , #eq^#(nil(), leaf()) -> c_32()
  , #eq^#(nil(), node(@y_1, @y_2, @y_3)) -> c_33()
  , #eq^#(leaf(), ::(@y_1, @y_2)) -> c_34()
  , #eq^#(leaf(), nil()) -> c_35()
  , #eq^#(leaf(), leaf()) -> c_36()
  , #eq^#(leaf(), node(@y_1, @y_2, @y_3)) -> c_37()
  , #eq^#(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2)) -> c_38()
  , #eq^#(node(@x_1, @x_2, @x_3), nil()) -> c_39()
  , #eq^#(node(@x_1, @x_2, @x_3), leaf()) -> c_40()
  , #eq^#(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) ->
    c_41(#and^#(#eq(@x_1, @y_1),
                #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3))),
         #eq^#(@x_1, @y_1),
         #and^#(#eq(@x_2, @y_2), #eq(@x_3, @y_3)),
         #eq^#(@x_2, @y_2),
         #eq^#(@x_3, @y_3))
  , #eq^#(#0(), #0()) -> c_42()
  , #eq^#(#0(), #neg(@y)) -> c_43()
  , #eq^#(#0(), #pos(@y)) -> c_44()
  , #eq^#(#0(), #s(@y)) -> c_45()
  , #eq^#(#neg(@x), #0()) -> c_46()
  , #eq^#(#neg(@x), #neg(@y)) -> c_47(#eq^#(@x, @y))
  , #eq^#(#neg(@x), #pos(@y)) -> c_48()
  , #eq^#(#pos(@x), #0()) -> c_49()
  , #eq^#(#pos(@x), #neg(@y)) -> c_50()
  , #eq^#(#pos(@x), #pos(@y)) -> c_51(#eq^#(@x, @y))
  , #eq^#(#s(@x), #0()) -> c_52()
  , #eq^#(#s(@x), #s(@y)) -> c_53(#eq^#(@x, @y))
  , #and^#(#false(), #false()) -> c_54()
  , #and^#(#false(), #true()) -> c_55()
  , #and^#(#true(), #false()) -> c_56()
  , #and^#(#true(), #true()) -> c_57() }
Weak Trs:
  { #equal(@x, @y) -> #eq(@x, @y)
  , #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
    #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
  , #eq(::(@x_1, @x_2), nil()) -> #false()
  , #eq(::(@x_1, @x_2), leaf()) -> #false()
  , #eq(::(@x_1, @x_2), node(@y_1, @y_2, @y_3)) -> #false()
  , #eq(nil(), ::(@y_1, @y_2)) -> #false()
  , #eq(nil(), nil()) -> #true()
  , #eq(nil(), leaf()) -> #false()
  , #eq(nil(), node(@y_1, @y_2, @y_3)) -> #false()
  , #eq(leaf(), ::(@y_1, @y_2)) -> #false()
  , #eq(leaf(), nil()) -> #false()
  , #eq(leaf(), leaf()) -> #true()
  , #eq(leaf(), node(@y_1, @y_2, @y_3)) -> #false()
  , #eq(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2)) -> #false()
  , #eq(node(@x_1, @x_2, @x_3), nil()) -> #false()
  , #eq(node(@x_1, @x_2, @x_3), leaf()) -> #false()
  , #eq(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) ->
    #and(#eq(@x_1, @y_1), #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3)))
  , #eq(#0(), #0()) -> #true()
  , #eq(#0(), #neg(@y)) -> #false()
  , #eq(#0(), #pos(@y)) -> #false()
  , #eq(#0(), #s(@y)) -> #false()
  , #eq(#neg(@x), #0()) -> #false()
  , #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
  , #eq(#neg(@x), #pos(@y)) -> #false()
  , #eq(#pos(@x), #0()) -> #false()
  , #eq(#pos(@x), #neg(@y)) -> #false()
  , #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
  , #eq(#s(@x), #0()) -> #false()
  , #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
  , appendreverse(@toreverse, @sofar) ->
    appendreverse#1(@toreverse, @sofar)
  , appendreverse#1(::(@a, @as), @sofar) ->
    appendreverse(@as, ::(@a, @sofar))
  , appendreverse#1(nil(), @sofar) -> @sofar
  , bfs(@queue, @futurequeue, @x) -> bfs#1(@queue, @futurequeue, @x)
  , bfs#1(::(@t, @ts), @futurequeue, @x) ->
    bfs#3(@t, @futurequeue, @ts, @x)
  , bfs#1(nil(), @futurequeue, @x) -> bfs#2(@futurequeue, @x)
  , bfs#3(leaf(), @futurequeue, @ts, @x) ->
    bfs(@ts, @futurequeue, @x)
  , bfs#3(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
    bfs#4(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y)
  , bfs#2(::(@t, @ts), @x) -> bfs(reverse(::(@t, @ts)), nil(), @x)
  , bfs#2(nil(), @x) -> leaf()
  , reverse(@xs) -> appendreverse(@xs, nil())
  , bfs#4(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
    bfs(@ts, ::(@t2, ::(@t1, @futurequeue)), @x)
  , bfs#4(#true(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
    node(@y, @t1, @t2)
  , bfs2(@t, @x) -> bfs2#1(dobfs(@t, @x), @x)
  , dobfs(@t, @x) -> bfs(::(@t, nil()), nil(), @x)
  , bfs2#1(@t', @x) -> dobfs(@t', @x)
  , dfs(@queue, @x) -> dfs#1(@queue, @x)
  , dfs#1(::(@t, @ts), @x) -> dfs#2(@t, @t, @ts, @x)
  , dfs#1(nil(), @x) -> leaf()
  , dfs#2(leaf(), @t, @ts, @x) -> dfs(@ts, @x)
  , dfs#2(node(@a, @t1, @t2), @t, @ts, @x) ->
    dfs#3(#equal(@a, @x), @t, @t1, @t2, @ts, @x)
  , dfs#3(#false(), @t, @t1, @t2, @ts, @x) ->
    dfs(::(@t1, ::(@t2, @ts)), @x)
  , dfs#3(#true(), @t, @t1, @t2, @ts, @x) -> @t
  , dodfs(@t, @x) -> dfs(::(@t, nil()), @x)
  , #and(#false(), #false()) -> #false()
  , #and(#false(), #true()) -> #false()
  , #and(#true(), #false()) -> #false()
  , #and(#true(), #true()) -> #true() }
Obligation:
  innermost runtime complexity
Answer:
  YES(O(1),O(n^2))

Consider the dependency graph

  1: #equal^#(@x, @y) -> c_1(#eq^#(@x, @y))
     -->_1 #eq^#(#s(@x), #s(@y)) -> c_53(#eq^#(@x, @y)) :53
     -->_1 #eq^#(#pos(@x), #pos(@y)) -> c_51(#eq^#(@x, @y)) :51
     -->_1 #eq^#(#neg(@x), #neg(@y)) -> c_47(#eq^#(@x, @y)) :47
     -->_1 #eq^#(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) ->
           c_41(#and^#(#eq(@x_1, @y_1),
                       #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3))),
                #eq^#(@x_1, @y_1),
                #and^#(#eq(@x_2, @y_2), #eq(@x_3, @y_3)),
                #eq^#(@x_2, @y_2),
                #eq^#(@x_3, @y_3)) :41
     -->_1 #eq^#(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
           c_26(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)),
                #eq^#(@x_1, @y_1),
                #eq^#(@x_2, @y_2)) :26
     -->_1 #eq^#(#s(@x), #0()) -> c_52() :52
     -->_1 #eq^#(#pos(@x), #neg(@y)) -> c_50() :50
     -->_1 #eq^#(#pos(@x), #0()) -> c_49() :49
     -->_1 #eq^#(#neg(@x), #pos(@y)) -> c_48() :48
     -->_1 #eq^#(#neg(@x), #0()) -> c_46() :46
     -->_1 #eq^#(#0(), #s(@y)) -> c_45() :45
     -->_1 #eq^#(#0(), #pos(@y)) -> c_44() :44
     -->_1 #eq^#(#0(), #neg(@y)) -> c_43() :43
     -->_1 #eq^#(#0(), #0()) -> c_42() :42
     -->_1 #eq^#(node(@x_1, @x_2, @x_3), leaf()) -> c_40() :40
     -->_1 #eq^#(node(@x_1, @x_2, @x_3), nil()) -> c_39() :39
     -->_1 #eq^#(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2)) -> c_38() :38
     -->_1 #eq^#(leaf(), node(@y_1, @y_2, @y_3)) -> c_37() :37
     -->_1 #eq^#(leaf(), leaf()) -> c_36() :36
     -->_1 #eq^#(leaf(), nil()) -> c_35() :35
     -->_1 #eq^#(leaf(), ::(@y_1, @y_2)) -> c_34() :34
     -->_1 #eq^#(nil(), node(@y_1, @y_2, @y_3)) -> c_33() :33
     -->_1 #eq^#(nil(), leaf()) -> c_32() :32
     -->_1 #eq^#(nil(), nil()) -> c_31() :31
     -->_1 #eq^#(nil(), ::(@y_1, @y_2)) -> c_30() :30
     -->_1 #eq^#(::(@x_1, @x_2), node(@y_1, @y_2, @y_3)) -> c_29() :29
     -->_1 #eq^#(::(@x_1, @x_2), leaf()) -> c_28() :28
     -->_1 #eq^#(::(@x_1, @x_2), nil()) -> c_27() :27
  
  2: appendreverse^#(@toreverse, @sofar) ->
     c_2(appendreverse#1^#(@toreverse, @sofar))
     -->_1 appendreverse#1^#(::(@a, @as), @sofar) ->
           c_3(appendreverse^#(@as, ::(@a, @sofar))) :3
     -->_1 appendreverse#1^#(nil(), @sofar) -> c_4() :4
  
  3: appendreverse#1^#(::(@a, @as), @sofar) ->
     c_3(appendreverse^#(@as, ::(@a, @sofar)))
     -->_1 appendreverse^#(@toreverse, @sofar) ->
           c_2(appendreverse#1^#(@toreverse, @sofar)) :2
  
  4: appendreverse#1^#(nil(), @sofar) -> c_4()
  
  5: bfs^#(@queue, @futurequeue, @x) ->
     c_5(bfs#1^#(@queue, @futurequeue, @x))
     -->_1 bfs#1^#(nil(), @futurequeue, @x) ->
           c_7(bfs#2^#(@futurequeue, @x)) :7
     -->_1 bfs#1^#(::(@t, @ts), @futurequeue, @x) ->
           c_6(bfs#3^#(@t, @futurequeue, @ts, @x)) :6
  
  6: bfs#1^#(::(@t, @ts), @futurequeue, @x) ->
     c_6(bfs#3^#(@t, @futurequeue, @ts, @x))
     -->_1 bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
           c_9(bfs#4^#(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y),
               #equal^#(@x, @y)) :9
     -->_1 bfs#3^#(leaf(), @futurequeue, @ts, @x) ->
           c_8(bfs^#(@ts, @futurequeue, @x)) :8
  
  7: bfs#1^#(nil(), @futurequeue, @x) ->
     c_7(bfs#2^#(@futurequeue, @x))
     -->_1 bfs#2^#(::(@t, @ts), @x) ->
           c_10(bfs^#(reverse(::(@t, @ts)), nil(), @x),
                reverse^#(::(@t, @ts))) :10
     -->_1 bfs#2^#(nil(), @x) -> c_11() :11
  
  8: bfs#3^#(leaf(), @futurequeue, @ts, @x) ->
     c_8(bfs^#(@ts, @futurequeue, @x))
     -->_1 bfs^#(@queue, @futurequeue, @x) ->
           c_5(bfs#1^#(@queue, @futurequeue, @x)) :5
  
  9: bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
     c_9(bfs#4^#(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y),
         #equal^#(@x, @y))
     -->_1 bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
           c_13(bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x)) :12
     -->_1 bfs#4^#(#true(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
           c_14() :13
     -->_2 #equal^#(@x, @y) -> c_1(#eq^#(@x, @y)) :1
  
  10: bfs#2^#(::(@t, @ts), @x) ->
      c_10(bfs^#(reverse(::(@t, @ts)), nil(), @x),
           reverse^#(::(@t, @ts)))
     -->_2 reverse^#(@xs) -> c_12(appendreverse^#(@xs, nil())) :14
     -->_1 bfs^#(@queue, @futurequeue, @x) ->
           c_5(bfs#1^#(@queue, @futurequeue, @x)) :5
  
  11: bfs#2^#(nil(), @x) -> c_11()
  
  12: bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
      c_13(bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x))
     -->_1 bfs^#(@queue, @futurequeue, @x) ->
           c_5(bfs#1^#(@queue, @futurequeue, @x)) :5
  
  13: bfs#4^#(#true(), @futurequeue, @t1, @t2, @ts, @x, @y) -> c_14()
  
  14: reverse^#(@xs) -> c_12(appendreverse^#(@xs, nil()))
     -->_1 appendreverse^#(@toreverse, @sofar) ->
           c_2(appendreverse#1^#(@toreverse, @sofar)) :2
  
  15: bfs2^#(@t, @x) ->
      c_15(bfs2#1^#(dobfs(@t, @x), @x), dobfs^#(@t, @x))
     -->_2 dobfs^#(@t, @x) -> c_16(bfs^#(::(@t, nil()), nil(), @x)) :17
     -->_1 bfs2#1^#(@t', @x) -> c_17(dobfs^#(@t', @x)) :16
  
  16: bfs2#1^#(@t', @x) -> c_17(dobfs^#(@t', @x))
     -->_1 dobfs^#(@t, @x) -> c_16(bfs^#(::(@t, nil()), nil(), @x)) :17
  
  17: dobfs^#(@t, @x) -> c_16(bfs^#(::(@t, nil()), nil(), @x))
     -->_1 bfs^#(@queue, @futurequeue, @x) ->
           c_5(bfs#1^#(@queue, @futurequeue, @x)) :5
  
  18: dfs^#(@queue, @x) -> c_18(dfs#1^#(@queue, @x))
     -->_1 dfs#1^#(::(@t, @ts), @x) ->
           c_19(dfs#2^#(@t, @t, @ts, @x)) :19
     -->_1 dfs#1^#(nil(), @x) -> c_20() :20
  
  19: dfs#1^#(::(@t, @ts), @x) -> c_19(dfs#2^#(@t, @t, @ts, @x))
     -->_1 dfs#2^#(node(@a, @t1, @t2), @t, @ts, @x) ->
           c_22(dfs#3^#(#equal(@a, @x), @t, @t1, @t2, @ts, @x),
                #equal^#(@a, @x)) :22
     -->_1 dfs#2^#(leaf(), @t, @ts, @x) -> c_21(dfs^#(@ts, @x)) :21
  
  20: dfs#1^#(nil(), @x) -> c_20()
  
  21: dfs#2^#(leaf(), @t, @ts, @x) -> c_21(dfs^#(@ts, @x))
     -->_1 dfs^#(@queue, @x) -> c_18(dfs#1^#(@queue, @x)) :18
  
  22: dfs#2^#(node(@a, @t1, @t2), @t, @ts, @x) ->
      c_22(dfs#3^#(#equal(@a, @x), @t, @t1, @t2, @ts, @x),
           #equal^#(@a, @x))
     -->_1 dfs#3^#(#false(), @t, @t1, @t2, @ts, @x) ->
           c_23(dfs^#(::(@t1, ::(@t2, @ts)), @x)) :23
     -->_1 dfs#3^#(#true(), @t, @t1, @t2, @ts, @x) -> c_24() :24
     -->_2 #equal^#(@x, @y) -> c_1(#eq^#(@x, @y)) :1
  
  23: dfs#3^#(#false(), @t, @t1, @t2, @ts, @x) ->
      c_23(dfs^#(::(@t1, ::(@t2, @ts)), @x))
     -->_1 dfs^#(@queue, @x) -> c_18(dfs#1^#(@queue, @x)) :18
  
  24: dfs#3^#(#true(), @t, @t1, @t2, @ts, @x) -> c_24()
  
  25: dodfs^#(@t, @x) -> c_25(dfs^#(::(@t, nil()), @x))
     -->_1 dfs^#(@queue, @x) -> c_18(dfs#1^#(@queue, @x)) :18
  
  26: #eq^#(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
      c_26(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)),
           #eq^#(@x_1, @y_1),
           #eq^#(@x_2, @y_2))
     -->_3 #eq^#(#s(@x), #s(@y)) -> c_53(#eq^#(@x, @y)) :53
     -->_2 #eq^#(#s(@x), #s(@y)) -> c_53(#eq^#(@x, @y)) :53
     -->_3 #eq^#(#pos(@x), #pos(@y)) -> c_51(#eq^#(@x, @y)) :51
     -->_2 #eq^#(#pos(@x), #pos(@y)) -> c_51(#eq^#(@x, @y)) :51
     -->_3 #eq^#(#neg(@x), #neg(@y)) -> c_47(#eq^#(@x, @y)) :47
     -->_2 #eq^#(#neg(@x), #neg(@y)) -> c_47(#eq^#(@x, @y)) :47
     -->_3 #eq^#(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) ->
           c_41(#and^#(#eq(@x_1, @y_1),
                       #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3))),
                #eq^#(@x_1, @y_1),
                #and^#(#eq(@x_2, @y_2), #eq(@x_3, @y_3)),
                #eq^#(@x_2, @y_2),
                #eq^#(@x_3, @y_3)) :41
     -->_2 #eq^#(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) ->
           c_41(#and^#(#eq(@x_1, @y_1),
                       #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3))),
                #eq^#(@x_1, @y_1),
                #and^#(#eq(@x_2, @y_2), #eq(@x_3, @y_3)),
                #eq^#(@x_2, @y_2),
                #eq^#(@x_3, @y_3)) :41
     -->_1 #and^#(#true(), #true()) -> c_57() :57
     -->_1 #and^#(#true(), #false()) -> c_56() :56
     -->_1 #and^#(#false(), #true()) -> c_55() :55
     -->_1 #and^#(#false(), #false()) -> c_54() :54
     -->_3 #eq^#(#s(@x), #0()) -> c_52() :52
     -->_2 #eq^#(#s(@x), #0()) -> c_52() :52
     -->_3 #eq^#(#pos(@x), #neg(@y)) -> c_50() :50
     -->_2 #eq^#(#pos(@x), #neg(@y)) -> c_50() :50
     -->_3 #eq^#(#pos(@x), #0()) -> c_49() :49
     -->_2 #eq^#(#pos(@x), #0()) -> c_49() :49
     -->_3 #eq^#(#neg(@x), #pos(@y)) -> c_48() :48
     -->_2 #eq^#(#neg(@x), #pos(@y)) -> c_48() :48
     -->_3 #eq^#(#neg(@x), #0()) -> c_46() :46
     -->_2 #eq^#(#neg(@x), #0()) -> c_46() :46
     -->_3 #eq^#(#0(), #s(@y)) -> c_45() :45
     -->_2 #eq^#(#0(), #s(@y)) -> c_45() :45
     -->_3 #eq^#(#0(), #pos(@y)) -> c_44() :44
     -->_2 #eq^#(#0(), #pos(@y)) -> c_44() :44
     -->_3 #eq^#(#0(), #neg(@y)) -> c_43() :43
     -->_2 #eq^#(#0(), #neg(@y)) -> c_43() :43
     -->_3 #eq^#(#0(), #0()) -> c_42() :42
     -->_2 #eq^#(#0(), #0()) -> c_42() :42
     -->_3 #eq^#(node(@x_1, @x_2, @x_3), leaf()) -> c_40() :40
     -->_2 #eq^#(node(@x_1, @x_2, @x_3), leaf()) -> c_40() :40
     -->_3 #eq^#(node(@x_1, @x_2, @x_3), nil()) -> c_39() :39
     -->_2 #eq^#(node(@x_1, @x_2, @x_3), nil()) -> c_39() :39
     -->_3 #eq^#(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2)) -> c_38() :38
     -->_2 #eq^#(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2)) -> c_38() :38
     -->_3 #eq^#(leaf(), node(@y_1, @y_2, @y_3)) -> c_37() :37
     -->_2 #eq^#(leaf(), node(@y_1, @y_2, @y_3)) -> c_37() :37
     -->_3 #eq^#(leaf(), leaf()) -> c_36() :36
     -->_2 #eq^#(leaf(), leaf()) -> c_36() :36
     -->_3 #eq^#(leaf(), nil()) -> c_35() :35
     -->_2 #eq^#(leaf(), nil()) -> c_35() :35
     -->_3 #eq^#(leaf(), ::(@y_1, @y_2)) -> c_34() :34
     -->_2 #eq^#(leaf(), ::(@y_1, @y_2)) -> c_34() :34
     -->_3 #eq^#(nil(), node(@y_1, @y_2, @y_3)) -> c_33() :33
     -->_2 #eq^#(nil(), node(@y_1, @y_2, @y_3)) -> c_33() :33
     -->_3 #eq^#(nil(), leaf()) -> c_32() :32
     -->_2 #eq^#(nil(), leaf()) -> c_32() :32
     -->_3 #eq^#(nil(), nil()) -> c_31() :31
     -->_2 #eq^#(nil(), nil()) -> c_31() :31
     -->_3 #eq^#(nil(), ::(@y_1, @y_2)) -> c_30() :30
     -->_2 #eq^#(nil(), ::(@y_1, @y_2)) -> c_30() :30
     -->_3 #eq^#(::(@x_1, @x_2), node(@y_1, @y_2, @y_3)) -> c_29() :29
     -->_2 #eq^#(::(@x_1, @x_2), node(@y_1, @y_2, @y_3)) -> c_29() :29
     -->_3 #eq^#(::(@x_1, @x_2), leaf()) -> c_28() :28
     -->_2 #eq^#(::(@x_1, @x_2), leaf()) -> c_28() :28
     -->_3 #eq^#(::(@x_1, @x_2), nil()) -> c_27() :27
     -->_2 #eq^#(::(@x_1, @x_2), nil()) -> c_27() :27
     -->_3 #eq^#(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
           c_26(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)),
                #eq^#(@x_1, @y_1),
                #eq^#(@x_2, @y_2)) :26
     -->_2 #eq^#(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
           c_26(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)),
                #eq^#(@x_1, @y_1),
                #eq^#(@x_2, @y_2)) :26
  
  27: #eq^#(::(@x_1, @x_2), nil()) -> c_27()
  
  28: #eq^#(::(@x_1, @x_2), leaf()) -> c_28()
  
  29: #eq^#(::(@x_1, @x_2), node(@y_1, @y_2, @y_3)) -> c_29()
  
  30: #eq^#(nil(), ::(@y_1, @y_2)) -> c_30()
  
  31: #eq^#(nil(), nil()) -> c_31()
  
  32: #eq^#(nil(), leaf()) -> c_32()
  
  33: #eq^#(nil(), node(@y_1, @y_2, @y_3)) -> c_33()
  
  34: #eq^#(leaf(), ::(@y_1, @y_2)) -> c_34()
  
  35: #eq^#(leaf(), nil()) -> c_35()
  
  36: #eq^#(leaf(), leaf()) -> c_36()
  
  37: #eq^#(leaf(), node(@y_1, @y_2, @y_3)) -> c_37()
  
  38: #eq^#(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2)) -> c_38()
  
  39: #eq^#(node(@x_1, @x_2, @x_3), nil()) -> c_39()
  
  40: #eq^#(node(@x_1, @x_2, @x_3), leaf()) -> c_40()
  
  41: #eq^#(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) ->
      c_41(#and^#(#eq(@x_1, @y_1),
                  #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3))),
           #eq^#(@x_1, @y_1),
           #and^#(#eq(@x_2, @y_2), #eq(@x_3, @y_3)),
           #eq^#(@x_2, @y_2),
           #eq^#(@x_3, @y_3))
     -->_5 #eq^#(#s(@x), #s(@y)) -> c_53(#eq^#(@x, @y)) :53
     -->_4 #eq^#(#s(@x), #s(@y)) -> c_53(#eq^#(@x, @y)) :53
     -->_2 #eq^#(#s(@x), #s(@y)) -> c_53(#eq^#(@x, @y)) :53
     -->_5 #eq^#(#pos(@x), #pos(@y)) -> c_51(#eq^#(@x, @y)) :51
     -->_4 #eq^#(#pos(@x), #pos(@y)) -> c_51(#eq^#(@x, @y)) :51
     -->_2 #eq^#(#pos(@x), #pos(@y)) -> c_51(#eq^#(@x, @y)) :51
     -->_5 #eq^#(#neg(@x), #neg(@y)) -> c_47(#eq^#(@x, @y)) :47
     -->_4 #eq^#(#neg(@x), #neg(@y)) -> c_47(#eq^#(@x, @y)) :47
     -->_2 #eq^#(#neg(@x), #neg(@y)) -> c_47(#eq^#(@x, @y)) :47
     -->_3 #and^#(#true(), #true()) -> c_57() :57
     -->_1 #and^#(#true(), #true()) -> c_57() :57
     -->_3 #and^#(#true(), #false()) -> c_56() :56
     -->_1 #and^#(#true(), #false()) -> c_56() :56
     -->_3 #and^#(#false(), #true()) -> c_55() :55
     -->_1 #and^#(#false(), #true()) -> c_55() :55
     -->_3 #and^#(#false(), #false()) -> c_54() :54
     -->_1 #and^#(#false(), #false()) -> c_54() :54
     -->_5 #eq^#(#s(@x), #0()) -> c_52() :52
     -->_4 #eq^#(#s(@x), #0()) -> c_52() :52
     -->_2 #eq^#(#s(@x), #0()) -> c_52() :52
     -->_5 #eq^#(#pos(@x), #neg(@y)) -> c_50() :50
     -->_4 #eq^#(#pos(@x), #neg(@y)) -> c_50() :50
     -->_2 #eq^#(#pos(@x), #neg(@y)) -> c_50() :50
     -->_5 #eq^#(#pos(@x), #0()) -> c_49() :49
     -->_4 #eq^#(#pos(@x), #0()) -> c_49() :49
     -->_2 #eq^#(#pos(@x), #0()) -> c_49() :49
     -->_5 #eq^#(#neg(@x), #pos(@y)) -> c_48() :48
     -->_4 #eq^#(#neg(@x), #pos(@y)) -> c_48() :48
     -->_2 #eq^#(#neg(@x), #pos(@y)) -> c_48() :48
     -->_5 #eq^#(#neg(@x), #0()) -> c_46() :46
     -->_4 #eq^#(#neg(@x), #0()) -> c_46() :46
     -->_2 #eq^#(#neg(@x), #0()) -> c_46() :46
     -->_5 #eq^#(#0(), #s(@y)) -> c_45() :45
     -->_4 #eq^#(#0(), #s(@y)) -> c_45() :45
     -->_2 #eq^#(#0(), #s(@y)) -> c_45() :45
     -->_5 #eq^#(#0(), #pos(@y)) -> c_44() :44
     -->_4 #eq^#(#0(), #pos(@y)) -> c_44() :44
     -->_2 #eq^#(#0(), #pos(@y)) -> c_44() :44
     -->_5 #eq^#(#0(), #neg(@y)) -> c_43() :43
     -->_4 #eq^#(#0(), #neg(@y)) -> c_43() :43
     -->_2 #eq^#(#0(), #neg(@y)) -> c_43() :43
     -->_5 #eq^#(#0(), #0()) -> c_42() :42
     -->_4 #eq^#(#0(), #0()) -> c_42() :42
     -->_2 #eq^#(#0(), #0()) -> c_42() :42
     -->_5 #eq^#(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) ->
           c_41(#and^#(#eq(@x_1, @y_1),
                       #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3))),
                #eq^#(@x_1, @y_1),
                #and^#(#eq(@x_2, @y_2), #eq(@x_3, @y_3)),
                #eq^#(@x_2, @y_2),
                #eq^#(@x_3, @y_3)) :41
     -->_4 #eq^#(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) ->
           c_41(#and^#(#eq(@x_1, @y_1),
                       #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3))),
                #eq^#(@x_1, @y_1),
                #and^#(#eq(@x_2, @y_2), #eq(@x_3, @y_3)),
                #eq^#(@x_2, @y_2),
                #eq^#(@x_3, @y_3)) :41
     -->_2 #eq^#(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) ->
           c_41(#and^#(#eq(@x_1, @y_1),
                       #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3))),
                #eq^#(@x_1, @y_1),
                #and^#(#eq(@x_2, @y_2), #eq(@x_3, @y_3)),
                #eq^#(@x_2, @y_2),
                #eq^#(@x_3, @y_3)) :41
     -->_5 #eq^#(node(@x_1, @x_2, @x_3), leaf()) -> c_40() :40
     -->_4 #eq^#(node(@x_1, @x_2, @x_3), leaf()) -> c_40() :40
     -->_2 #eq^#(node(@x_1, @x_2, @x_3), leaf()) -> c_40() :40
     -->_5 #eq^#(node(@x_1, @x_2, @x_3), nil()) -> c_39() :39
     -->_4 #eq^#(node(@x_1, @x_2, @x_3), nil()) -> c_39() :39
     -->_2 #eq^#(node(@x_1, @x_2, @x_3), nil()) -> c_39() :39
     -->_5 #eq^#(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2)) -> c_38() :38
     -->_4 #eq^#(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2)) -> c_38() :38
     -->_2 #eq^#(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2)) -> c_38() :38
     -->_5 #eq^#(leaf(), node(@y_1, @y_2, @y_3)) -> c_37() :37
     -->_4 #eq^#(leaf(), node(@y_1, @y_2, @y_3)) -> c_37() :37
     -->_2 #eq^#(leaf(), node(@y_1, @y_2, @y_3)) -> c_37() :37
     -->_5 #eq^#(leaf(), leaf()) -> c_36() :36
     -->_4 #eq^#(leaf(), leaf()) -> c_36() :36
     -->_2 #eq^#(leaf(), leaf()) -> c_36() :36
     -->_5 #eq^#(leaf(), nil()) -> c_35() :35
     -->_4 #eq^#(leaf(), nil()) -> c_35() :35
     -->_2 #eq^#(leaf(), nil()) -> c_35() :35
     -->_5 #eq^#(leaf(), ::(@y_1, @y_2)) -> c_34() :34
     -->_4 #eq^#(leaf(), ::(@y_1, @y_2)) -> c_34() :34
     -->_2 #eq^#(leaf(), ::(@y_1, @y_2)) -> c_34() :34
     -->_5 #eq^#(nil(), node(@y_1, @y_2, @y_3)) -> c_33() :33
     -->_4 #eq^#(nil(), node(@y_1, @y_2, @y_3)) -> c_33() :33
     -->_2 #eq^#(nil(), node(@y_1, @y_2, @y_3)) -> c_33() :33
     -->_5 #eq^#(nil(), leaf()) -> c_32() :32
     -->_4 #eq^#(nil(), leaf()) -> c_32() :32
     -->_2 #eq^#(nil(), leaf()) -> c_32() :32
     -->_5 #eq^#(nil(), nil()) -> c_31() :31
     -->_4 #eq^#(nil(), nil()) -> c_31() :31
     -->_2 #eq^#(nil(), nil()) -> c_31() :31
     -->_5 #eq^#(nil(), ::(@y_1, @y_2)) -> c_30() :30
     -->_4 #eq^#(nil(), ::(@y_1, @y_2)) -> c_30() :30
     -->_2 #eq^#(nil(), ::(@y_1, @y_2)) -> c_30() :30
     -->_5 #eq^#(::(@x_1, @x_2), node(@y_1, @y_2, @y_3)) -> c_29() :29
     -->_4 #eq^#(::(@x_1, @x_2), node(@y_1, @y_2, @y_3)) -> c_29() :29
     -->_2 #eq^#(::(@x_1, @x_2), node(@y_1, @y_2, @y_3)) -> c_29() :29
     -->_5 #eq^#(::(@x_1, @x_2), leaf()) -> c_28() :28
     -->_4 #eq^#(::(@x_1, @x_2), leaf()) -> c_28() :28
     -->_2 #eq^#(::(@x_1, @x_2), leaf()) -> c_28() :28
     -->_5 #eq^#(::(@x_1, @x_2), nil()) -> c_27() :27
     -->_4 #eq^#(::(@x_1, @x_2), nil()) -> c_27() :27
     -->_2 #eq^#(::(@x_1, @x_2), nil()) -> c_27() :27
     -->_5 #eq^#(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
           c_26(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)),
                #eq^#(@x_1, @y_1),
                #eq^#(@x_2, @y_2)) :26
     -->_4 #eq^#(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
           c_26(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)),
                #eq^#(@x_1, @y_1),
                #eq^#(@x_2, @y_2)) :26
     -->_2 #eq^#(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
           c_26(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)),
                #eq^#(@x_1, @y_1),
                #eq^#(@x_2, @y_2)) :26
  
  42: #eq^#(#0(), #0()) -> c_42()
  
  43: #eq^#(#0(), #neg(@y)) -> c_43()
  
  44: #eq^#(#0(), #pos(@y)) -> c_44()
  
  45: #eq^#(#0(), #s(@y)) -> c_45()
  
  46: #eq^#(#neg(@x), #0()) -> c_46()
  
  47: #eq^#(#neg(@x), #neg(@y)) -> c_47(#eq^#(@x, @y))
     -->_1 #eq^#(#s(@x), #s(@y)) -> c_53(#eq^#(@x, @y)) :53
     -->_1 #eq^#(#pos(@x), #pos(@y)) -> c_51(#eq^#(@x, @y)) :51
     -->_1 #eq^#(#s(@x), #0()) -> c_52() :52
     -->_1 #eq^#(#pos(@x), #neg(@y)) -> c_50() :50
     -->_1 #eq^#(#pos(@x), #0()) -> c_49() :49
     -->_1 #eq^#(#neg(@x), #pos(@y)) -> c_48() :48
     -->_1 #eq^#(#neg(@x), #neg(@y)) -> c_47(#eq^#(@x, @y)) :47
     -->_1 #eq^#(#neg(@x), #0()) -> c_46() :46
     -->_1 #eq^#(#0(), #s(@y)) -> c_45() :45
     -->_1 #eq^#(#0(), #pos(@y)) -> c_44() :44
     -->_1 #eq^#(#0(), #neg(@y)) -> c_43() :43
     -->_1 #eq^#(#0(), #0()) -> c_42() :42
     -->_1 #eq^#(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) ->
           c_41(#and^#(#eq(@x_1, @y_1),
                       #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3))),
                #eq^#(@x_1, @y_1),
                #and^#(#eq(@x_2, @y_2), #eq(@x_3, @y_3)),
                #eq^#(@x_2, @y_2),
                #eq^#(@x_3, @y_3)) :41
     -->_1 #eq^#(node(@x_1, @x_2, @x_3), leaf()) -> c_40() :40
     -->_1 #eq^#(node(@x_1, @x_2, @x_3), nil()) -> c_39() :39
     -->_1 #eq^#(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2)) -> c_38() :38
     -->_1 #eq^#(leaf(), node(@y_1, @y_2, @y_3)) -> c_37() :37
     -->_1 #eq^#(leaf(), leaf()) -> c_36() :36
     -->_1 #eq^#(leaf(), nil()) -> c_35() :35
     -->_1 #eq^#(leaf(), ::(@y_1, @y_2)) -> c_34() :34
     -->_1 #eq^#(nil(), node(@y_1, @y_2, @y_3)) -> c_33() :33
     -->_1 #eq^#(nil(), leaf()) -> c_32() :32
     -->_1 #eq^#(nil(), nil()) -> c_31() :31
     -->_1 #eq^#(nil(), ::(@y_1, @y_2)) -> c_30() :30
     -->_1 #eq^#(::(@x_1, @x_2), node(@y_1, @y_2, @y_3)) -> c_29() :29
     -->_1 #eq^#(::(@x_1, @x_2), leaf()) -> c_28() :28
     -->_1 #eq^#(::(@x_1, @x_2), nil()) -> c_27() :27
     -->_1 #eq^#(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
           c_26(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)),
                #eq^#(@x_1, @y_1),
                #eq^#(@x_2, @y_2)) :26
  
  48: #eq^#(#neg(@x), #pos(@y)) -> c_48()
  
  49: #eq^#(#pos(@x), #0()) -> c_49()
  
  50: #eq^#(#pos(@x), #neg(@y)) -> c_50()
  
  51: #eq^#(#pos(@x), #pos(@y)) -> c_51(#eq^#(@x, @y))
     -->_1 #eq^#(#s(@x), #s(@y)) -> c_53(#eq^#(@x, @y)) :53
     -->_1 #eq^#(#s(@x), #0()) -> c_52() :52
     -->_1 #eq^#(#pos(@x), #pos(@y)) -> c_51(#eq^#(@x, @y)) :51
     -->_1 #eq^#(#pos(@x), #neg(@y)) -> c_50() :50
     -->_1 #eq^#(#pos(@x), #0()) -> c_49() :49
     -->_1 #eq^#(#neg(@x), #pos(@y)) -> c_48() :48
     -->_1 #eq^#(#neg(@x), #neg(@y)) -> c_47(#eq^#(@x, @y)) :47
     -->_1 #eq^#(#neg(@x), #0()) -> c_46() :46
     -->_1 #eq^#(#0(), #s(@y)) -> c_45() :45
     -->_1 #eq^#(#0(), #pos(@y)) -> c_44() :44
     -->_1 #eq^#(#0(), #neg(@y)) -> c_43() :43
     -->_1 #eq^#(#0(), #0()) -> c_42() :42
     -->_1 #eq^#(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) ->
           c_41(#and^#(#eq(@x_1, @y_1),
                       #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3))),
                #eq^#(@x_1, @y_1),
                #and^#(#eq(@x_2, @y_2), #eq(@x_3, @y_3)),
                #eq^#(@x_2, @y_2),
                #eq^#(@x_3, @y_3)) :41
     -->_1 #eq^#(node(@x_1, @x_2, @x_3), leaf()) -> c_40() :40
     -->_1 #eq^#(node(@x_1, @x_2, @x_3), nil()) -> c_39() :39
     -->_1 #eq^#(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2)) -> c_38() :38
     -->_1 #eq^#(leaf(), node(@y_1, @y_2, @y_3)) -> c_37() :37
     -->_1 #eq^#(leaf(), leaf()) -> c_36() :36
     -->_1 #eq^#(leaf(), nil()) -> c_35() :35
     -->_1 #eq^#(leaf(), ::(@y_1, @y_2)) -> c_34() :34
     -->_1 #eq^#(nil(), node(@y_1, @y_2, @y_3)) -> c_33() :33
     -->_1 #eq^#(nil(), leaf()) -> c_32() :32
     -->_1 #eq^#(nil(), nil()) -> c_31() :31
     -->_1 #eq^#(nil(), ::(@y_1, @y_2)) -> c_30() :30
     -->_1 #eq^#(::(@x_1, @x_2), node(@y_1, @y_2, @y_3)) -> c_29() :29
     -->_1 #eq^#(::(@x_1, @x_2), leaf()) -> c_28() :28
     -->_1 #eq^#(::(@x_1, @x_2), nil()) -> c_27() :27
     -->_1 #eq^#(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
           c_26(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)),
                #eq^#(@x_1, @y_1),
                #eq^#(@x_2, @y_2)) :26
  
  52: #eq^#(#s(@x), #0()) -> c_52()
  
  53: #eq^#(#s(@x), #s(@y)) -> c_53(#eq^#(@x, @y))
     -->_1 #eq^#(#s(@x), #s(@y)) -> c_53(#eq^#(@x, @y)) :53
     -->_1 #eq^#(#s(@x), #0()) -> c_52() :52
     -->_1 #eq^#(#pos(@x), #pos(@y)) -> c_51(#eq^#(@x, @y)) :51
     -->_1 #eq^#(#pos(@x), #neg(@y)) -> c_50() :50
     -->_1 #eq^#(#pos(@x), #0()) -> c_49() :49
     -->_1 #eq^#(#neg(@x), #pos(@y)) -> c_48() :48
     -->_1 #eq^#(#neg(@x), #neg(@y)) -> c_47(#eq^#(@x, @y)) :47
     -->_1 #eq^#(#neg(@x), #0()) -> c_46() :46
     -->_1 #eq^#(#0(), #s(@y)) -> c_45() :45
     -->_1 #eq^#(#0(), #pos(@y)) -> c_44() :44
     -->_1 #eq^#(#0(), #neg(@y)) -> c_43() :43
     -->_1 #eq^#(#0(), #0()) -> c_42() :42
     -->_1 #eq^#(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) ->
           c_41(#and^#(#eq(@x_1, @y_1),
                       #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3))),
                #eq^#(@x_1, @y_1),
                #and^#(#eq(@x_2, @y_2), #eq(@x_3, @y_3)),
                #eq^#(@x_2, @y_2),
                #eq^#(@x_3, @y_3)) :41
     -->_1 #eq^#(node(@x_1, @x_2, @x_3), leaf()) -> c_40() :40
     -->_1 #eq^#(node(@x_1, @x_2, @x_3), nil()) -> c_39() :39
     -->_1 #eq^#(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2)) -> c_38() :38
     -->_1 #eq^#(leaf(), node(@y_1, @y_2, @y_3)) -> c_37() :37
     -->_1 #eq^#(leaf(), leaf()) -> c_36() :36
     -->_1 #eq^#(leaf(), nil()) -> c_35() :35
     -->_1 #eq^#(leaf(), ::(@y_1, @y_2)) -> c_34() :34
     -->_1 #eq^#(nil(), node(@y_1, @y_2, @y_3)) -> c_33() :33
     -->_1 #eq^#(nil(), leaf()) -> c_32() :32
     -->_1 #eq^#(nil(), nil()) -> c_31() :31
     -->_1 #eq^#(nil(), ::(@y_1, @y_2)) -> c_30() :30
     -->_1 #eq^#(::(@x_1, @x_2), node(@y_1, @y_2, @y_3)) -> c_29() :29
     -->_1 #eq^#(::(@x_1, @x_2), leaf()) -> c_28() :28
     -->_1 #eq^#(::(@x_1, @x_2), nil()) -> c_27() :27
     -->_1 #eq^#(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
           c_26(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)),
                #eq^#(@x_1, @y_1),
                #eq^#(@x_2, @y_2)) :26
  
  54: #and^#(#false(), #false()) -> c_54()
  
  55: #and^#(#false(), #true()) -> c_55()
  
  56: #and^#(#true(), #false()) -> c_56()
  
  57: #and^#(#true(), #true()) -> c_57()
  

Following roots of the dependency graph are removed, as the
considered set of starting terms is closed under reduction with
respect to these rules (modulo compound contexts).

  { dodfs^#(@t, @x) -> c_25(dfs^#(::(@t, nil()), @x)) }


We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^2)).

Strict DPs:
  { #equal^#(@x, @y) -> c_1(#eq^#(@x, @y))
  , appendreverse^#(@toreverse, @sofar) ->
    c_2(appendreverse#1^#(@toreverse, @sofar))
  , appendreverse#1^#(::(@a, @as), @sofar) ->
    c_3(appendreverse^#(@as, ::(@a, @sofar)))
  , appendreverse#1^#(nil(), @sofar) -> c_4()
  , bfs^#(@queue, @futurequeue, @x) ->
    c_5(bfs#1^#(@queue, @futurequeue, @x))
  , bfs#1^#(::(@t, @ts), @futurequeue, @x) ->
    c_6(bfs#3^#(@t, @futurequeue, @ts, @x))
  , bfs#1^#(nil(), @futurequeue, @x) ->
    c_7(bfs#2^#(@futurequeue, @x))
  , bfs#3^#(leaf(), @futurequeue, @ts, @x) ->
    c_8(bfs^#(@ts, @futurequeue, @x))
  , bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
    c_9(bfs#4^#(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y),
        #equal^#(@x, @y))
  , bfs#2^#(::(@t, @ts), @x) ->
    c_10(bfs^#(reverse(::(@t, @ts)), nil(), @x),
         reverse^#(::(@t, @ts)))
  , bfs#2^#(nil(), @x) -> c_11()
  , bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
    c_13(bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x))
  , bfs#4^#(#true(), @futurequeue, @t1, @t2, @ts, @x, @y) -> c_14()
  , reverse^#(@xs) -> c_12(appendreverse^#(@xs, nil()))
  , bfs2^#(@t, @x) ->
    c_15(bfs2#1^#(dobfs(@t, @x), @x), dobfs^#(@t, @x))
  , bfs2#1^#(@t', @x) -> c_17(dobfs^#(@t', @x))
  , dobfs^#(@t, @x) -> c_16(bfs^#(::(@t, nil()), nil(), @x))
  , dfs^#(@queue, @x) -> c_18(dfs#1^#(@queue, @x))
  , dfs#1^#(::(@t, @ts), @x) -> c_19(dfs#2^#(@t, @t, @ts, @x))
  , dfs#1^#(nil(), @x) -> c_20()
  , dfs#2^#(leaf(), @t, @ts, @x) -> c_21(dfs^#(@ts, @x))
  , dfs#2^#(node(@a, @t1, @t2), @t, @ts, @x) ->
    c_22(dfs#3^#(#equal(@a, @x), @t, @t1, @t2, @ts, @x),
         #equal^#(@a, @x))
  , dfs#3^#(#false(), @t, @t1, @t2, @ts, @x) ->
    c_23(dfs^#(::(@t1, ::(@t2, @ts)), @x))
  , dfs#3^#(#true(), @t, @t1, @t2, @ts, @x) -> c_24() }
Weak DPs:
  { #eq^#(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
    c_26(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)),
         #eq^#(@x_1, @y_1),
         #eq^#(@x_2, @y_2))
  , #eq^#(::(@x_1, @x_2), nil()) -> c_27()
  , #eq^#(::(@x_1, @x_2), leaf()) -> c_28()
  , #eq^#(::(@x_1, @x_2), node(@y_1, @y_2, @y_3)) -> c_29()
  , #eq^#(nil(), ::(@y_1, @y_2)) -> c_30()
  , #eq^#(nil(), nil()) -> c_31()
  , #eq^#(nil(), leaf()) -> c_32()
  , #eq^#(nil(), node(@y_1, @y_2, @y_3)) -> c_33()
  , #eq^#(leaf(), ::(@y_1, @y_2)) -> c_34()
  , #eq^#(leaf(), nil()) -> c_35()
  , #eq^#(leaf(), leaf()) -> c_36()
  , #eq^#(leaf(), node(@y_1, @y_2, @y_3)) -> c_37()
  , #eq^#(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2)) -> c_38()
  , #eq^#(node(@x_1, @x_2, @x_3), nil()) -> c_39()
  , #eq^#(node(@x_1, @x_2, @x_3), leaf()) -> c_40()
  , #eq^#(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) ->
    c_41(#and^#(#eq(@x_1, @y_1),
                #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3))),
         #eq^#(@x_1, @y_1),
         #and^#(#eq(@x_2, @y_2), #eq(@x_3, @y_3)),
         #eq^#(@x_2, @y_2),
         #eq^#(@x_3, @y_3))
  , #eq^#(#0(), #0()) -> c_42()
  , #eq^#(#0(), #neg(@y)) -> c_43()
  , #eq^#(#0(), #pos(@y)) -> c_44()
  , #eq^#(#0(), #s(@y)) -> c_45()
  , #eq^#(#neg(@x), #0()) -> c_46()
  , #eq^#(#neg(@x), #neg(@y)) -> c_47(#eq^#(@x, @y))
  , #eq^#(#neg(@x), #pos(@y)) -> c_48()
  , #eq^#(#pos(@x), #0()) -> c_49()
  , #eq^#(#pos(@x), #neg(@y)) -> c_50()
  , #eq^#(#pos(@x), #pos(@y)) -> c_51(#eq^#(@x, @y))
  , #eq^#(#s(@x), #0()) -> c_52()
  , #eq^#(#s(@x), #s(@y)) -> c_53(#eq^#(@x, @y))
  , #and^#(#false(), #false()) -> c_54()
  , #and^#(#false(), #true()) -> c_55()
  , #and^#(#true(), #false()) -> c_56()
  , #and^#(#true(), #true()) -> c_57() }
Weak Trs:
  { #equal(@x, @y) -> #eq(@x, @y)
  , #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
    #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
  , #eq(::(@x_1, @x_2), nil()) -> #false()
  , #eq(::(@x_1, @x_2), leaf()) -> #false()
  , #eq(::(@x_1, @x_2), node(@y_1, @y_2, @y_3)) -> #false()
  , #eq(nil(), ::(@y_1, @y_2)) -> #false()
  , #eq(nil(), nil()) -> #true()
  , #eq(nil(), leaf()) -> #false()
  , #eq(nil(), node(@y_1, @y_2, @y_3)) -> #false()
  , #eq(leaf(), ::(@y_1, @y_2)) -> #false()
  , #eq(leaf(), nil()) -> #false()
  , #eq(leaf(), leaf()) -> #true()
  , #eq(leaf(), node(@y_1, @y_2, @y_3)) -> #false()
  , #eq(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2)) -> #false()
  , #eq(node(@x_1, @x_2, @x_3), nil()) -> #false()
  , #eq(node(@x_1, @x_2, @x_3), leaf()) -> #false()
  , #eq(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) ->
    #and(#eq(@x_1, @y_1), #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3)))
  , #eq(#0(), #0()) -> #true()
  , #eq(#0(), #neg(@y)) -> #false()
  , #eq(#0(), #pos(@y)) -> #false()
  , #eq(#0(), #s(@y)) -> #false()
  , #eq(#neg(@x), #0()) -> #false()
  , #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
  , #eq(#neg(@x), #pos(@y)) -> #false()
  , #eq(#pos(@x), #0()) -> #false()
  , #eq(#pos(@x), #neg(@y)) -> #false()
  , #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
  , #eq(#s(@x), #0()) -> #false()
  , #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
  , appendreverse(@toreverse, @sofar) ->
    appendreverse#1(@toreverse, @sofar)
  , appendreverse#1(::(@a, @as), @sofar) ->
    appendreverse(@as, ::(@a, @sofar))
  , appendreverse#1(nil(), @sofar) -> @sofar
  , bfs(@queue, @futurequeue, @x) -> bfs#1(@queue, @futurequeue, @x)
  , bfs#1(::(@t, @ts), @futurequeue, @x) ->
    bfs#3(@t, @futurequeue, @ts, @x)
  , bfs#1(nil(), @futurequeue, @x) -> bfs#2(@futurequeue, @x)
  , bfs#3(leaf(), @futurequeue, @ts, @x) ->
    bfs(@ts, @futurequeue, @x)
  , bfs#3(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
    bfs#4(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y)
  , bfs#2(::(@t, @ts), @x) -> bfs(reverse(::(@t, @ts)), nil(), @x)
  , bfs#2(nil(), @x) -> leaf()
  , reverse(@xs) -> appendreverse(@xs, nil())
  , bfs#4(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
    bfs(@ts, ::(@t2, ::(@t1, @futurequeue)), @x)
  , bfs#4(#true(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
    node(@y, @t1, @t2)
  , bfs2(@t, @x) -> bfs2#1(dobfs(@t, @x), @x)
  , dobfs(@t, @x) -> bfs(::(@t, nil()), nil(), @x)
  , bfs2#1(@t', @x) -> dobfs(@t', @x)
  , dfs(@queue, @x) -> dfs#1(@queue, @x)
  , dfs#1(::(@t, @ts), @x) -> dfs#2(@t, @t, @ts, @x)
  , dfs#1(nil(), @x) -> leaf()
  , dfs#2(leaf(), @t, @ts, @x) -> dfs(@ts, @x)
  , dfs#2(node(@a, @t1, @t2), @t, @ts, @x) ->
    dfs#3(#equal(@a, @x), @t, @t1, @t2, @ts, @x)
  , dfs#3(#false(), @t, @t1, @t2, @ts, @x) ->
    dfs(::(@t1, ::(@t2, @ts)), @x)
  , dfs#3(#true(), @t, @t1, @t2, @ts, @x) -> @t
  , dodfs(@t, @x) -> dfs(::(@t, nil()), @x)
  , #and(#false(), #false()) -> #false()
  , #and(#false(), #true()) -> #false()
  , #and(#true(), #false()) -> #false()
  , #and(#true(), #true()) -> #true() }
Obligation:
  innermost runtime complexity
Answer:
  YES(O(1),O(n^2))

We estimate the number of application of {1,4,11,13,20,24} by
applications of Pre({1,4,11,13,20,24}) = {2,7,9,18,22}. Here rules
are labeled as follows:

  DPs:
    { 1: #equal^#(@x, @y) -> c_1(#eq^#(@x, @y))
    , 2: appendreverse^#(@toreverse, @sofar) ->
         c_2(appendreverse#1^#(@toreverse, @sofar))
    , 3: appendreverse#1^#(::(@a, @as), @sofar) ->
         c_3(appendreverse^#(@as, ::(@a, @sofar)))
    , 4: appendreverse#1^#(nil(), @sofar) -> c_4()
    , 5: bfs^#(@queue, @futurequeue, @x) ->
         c_5(bfs#1^#(@queue, @futurequeue, @x))
    , 6: bfs#1^#(::(@t, @ts), @futurequeue, @x) ->
         c_6(bfs#3^#(@t, @futurequeue, @ts, @x))
    , 7: bfs#1^#(nil(), @futurequeue, @x) ->
         c_7(bfs#2^#(@futurequeue, @x))
    , 8: bfs#3^#(leaf(), @futurequeue, @ts, @x) ->
         c_8(bfs^#(@ts, @futurequeue, @x))
    , 9: bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
         c_9(bfs#4^#(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y),
             #equal^#(@x, @y))
    , 10: bfs#2^#(::(@t, @ts), @x) ->
          c_10(bfs^#(reverse(::(@t, @ts)), nil(), @x),
               reverse^#(::(@t, @ts)))
    , 11: bfs#2^#(nil(), @x) -> c_11()
    , 12: bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
          c_13(bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x))
    , 13: bfs#4^#(#true(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
          c_14()
    , 14: reverse^#(@xs) -> c_12(appendreverse^#(@xs, nil()))
    , 15: bfs2^#(@t, @x) ->
          c_15(bfs2#1^#(dobfs(@t, @x), @x), dobfs^#(@t, @x))
    , 16: bfs2#1^#(@t', @x) -> c_17(dobfs^#(@t', @x))
    , 17: dobfs^#(@t, @x) -> c_16(bfs^#(::(@t, nil()), nil(), @x))
    , 18: dfs^#(@queue, @x) -> c_18(dfs#1^#(@queue, @x))
    , 19: dfs#1^#(::(@t, @ts), @x) -> c_19(dfs#2^#(@t, @t, @ts, @x))
    , 20: dfs#1^#(nil(), @x) -> c_20()
    , 21: dfs#2^#(leaf(), @t, @ts, @x) -> c_21(dfs^#(@ts, @x))
    , 22: dfs#2^#(node(@a, @t1, @t2), @t, @ts, @x) ->
          c_22(dfs#3^#(#equal(@a, @x), @t, @t1, @t2, @ts, @x),
               #equal^#(@a, @x))
    , 23: dfs#3^#(#false(), @t, @t1, @t2, @ts, @x) ->
          c_23(dfs^#(::(@t1, ::(@t2, @ts)), @x))
    , 24: dfs#3^#(#true(), @t, @t1, @t2, @ts, @x) -> c_24()
    , 25: #eq^#(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
          c_26(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)),
               #eq^#(@x_1, @y_1),
               #eq^#(@x_2, @y_2))
    , 26: #eq^#(::(@x_1, @x_2), nil()) -> c_27()
    , 27: #eq^#(::(@x_1, @x_2), leaf()) -> c_28()
    , 28: #eq^#(::(@x_1, @x_2), node(@y_1, @y_2, @y_3)) -> c_29()
    , 29: #eq^#(nil(), ::(@y_1, @y_2)) -> c_30()
    , 30: #eq^#(nil(), nil()) -> c_31()
    , 31: #eq^#(nil(), leaf()) -> c_32()
    , 32: #eq^#(nil(), node(@y_1, @y_2, @y_3)) -> c_33()
    , 33: #eq^#(leaf(), ::(@y_1, @y_2)) -> c_34()
    , 34: #eq^#(leaf(), nil()) -> c_35()
    , 35: #eq^#(leaf(), leaf()) -> c_36()
    , 36: #eq^#(leaf(), node(@y_1, @y_2, @y_3)) -> c_37()
    , 37: #eq^#(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2)) -> c_38()
    , 38: #eq^#(node(@x_1, @x_2, @x_3), nil()) -> c_39()
    , 39: #eq^#(node(@x_1, @x_2, @x_3), leaf()) -> c_40()
    , 40: #eq^#(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) ->
          c_41(#and^#(#eq(@x_1, @y_1),
                      #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3))),
               #eq^#(@x_1, @y_1),
               #and^#(#eq(@x_2, @y_2), #eq(@x_3, @y_3)),
               #eq^#(@x_2, @y_2),
               #eq^#(@x_3, @y_3))
    , 41: #eq^#(#0(), #0()) -> c_42()
    , 42: #eq^#(#0(), #neg(@y)) -> c_43()
    , 43: #eq^#(#0(), #pos(@y)) -> c_44()
    , 44: #eq^#(#0(), #s(@y)) -> c_45()
    , 45: #eq^#(#neg(@x), #0()) -> c_46()
    , 46: #eq^#(#neg(@x), #neg(@y)) -> c_47(#eq^#(@x, @y))
    , 47: #eq^#(#neg(@x), #pos(@y)) -> c_48()
    , 48: #eq^#(#pos(@x), #0()) -> c_49()
    , 49: #eq^#(#pos(@x), #neg(@y)) -> c_50()
    , 50: #eq^#(#pos(@x), #pos(@y)) -> c_51(#eq^#(@x, @y))
    , 51: #eq^#(#s(@x), #0()) -> c_52()
    , 52: #eq^#(#s(@x), #s(@y)) -> c_53(#eq^#(@x, @y))
    , 53: #and^#(#false(), #false()) -> c_54()
    , 54: #and^#(#false(), #true()) -> c_55()
    , 55: #and^#(#true(), #false()) -> c_56()
    , 56: #and^#(#true(), #true()) -> c_57() }

We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^2)).

Strict DPs:
  { appendreverse^#(@toreverse, @sofar) ->
    c_2(appendreverse#1^#(@toreverse, @sofar))
  , appendreverse#1^#(::(@a, @as), @sofar) ->
    c_3(appendreverse^#(@as, ::(@a, @sofar)))
  , bfs^#(@queue, @futurequeue, @x) ->
    c_5(bfs#1^#(@queue, @futurequeue, @x))
  , bfs#1^#(::(@t, @ts), @futurequeue, @x) ->
    c_6(bfs#3^#(@t, @futurequeue, @ts, @x))
  , bfs#1^#(nil(), @futurequeue, @x) ->
    c_7(bfs#2^#(@futurequeue, @x))
  , bfs#3^#(leaf(), @futurequeue, @ts, @x) ->
    c_8(bfs^#(@ts, @futurequeue, @x))
  , bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
    c_9(bfs#4^#(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y),
        #equal^#(@x, @y))
  , bfs#2^#(::(@t, @ts), @x) ->
    c_10(bfs^#(reverse(::(@t, @ts)), nil(), @x),
         reverse^#(::(@t, @ts)))
  , bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
    c_13(bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x))
  , reverse^#(@xs) -> c_12(appendreverse^#(@xs, nil()))
  , bfs2^#(@t, @x) ->
    c_15(bfs2#1^#(dobfs(@t, @x), @x), dobfs^#(@t, @x))
  , bfs2#1^#(@t', @x) -> c_17(dobfs^#(@t', @x))
  , dobfs^#(@t, @x) -> c_16(bfs^#(::(@t, nil()), nil(), @x))
  , dfs^#(@queue, @x) -> c_18(dfs#1^#(@queue, @x))
  , dfs#1^#(::(@t, @ts), @x) -> c_19(dfs#2^#(@t, @t, @ts, @x))
  , dfs#2^#(leaf(), @t, @ts, @x) -> c_21(dfs^#(@ts, @x))
  , dfs#2^#(node(@a, @t1, @t2), @t, @ts, @x) ->
    c_22(dfs#3^#(#equal(@a, @x), @t, @t1, @t2, @ts, @x),
         #equal^#(@a, @x))
  , dfs#3^#(#false(), @t, @t1, @t2, @ts, @x) ->
    c_23(dfs^#(::(@t1, ::(@t2, @ts)), @x)) }
Weak DPs:
  { #equal^#(@x, @y) -> c_1(#eq^#(@x, @y))
  , #eq^#(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
    c_26(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)),
         #eq^#(@x_1, @y_1),
         #eq^#(@x_2, @y_2))
  , #eq^#(::(@x_1, @x_2), nil()) -> c_27()
  , #eq^#(::(@x_1, @x_2), leaf()) -> c_28()
  , #eq^#(::(@x_1, @x_2), node(@y_1, @y_2, @y_3)) -> c_29()
  , #eq^#(nil(), ::(@y_1, @y_2)) -> c_30()
  , #eq^#(nil(), nil()) -> c_31()
  , #eq^#(nil(), leaf()) -> c_32()
  , #eq^#(nil(), node(@y_1, @y_2, @y_3)) -> c_33()
  , #eq^#(leaf(), ::(@y_1, @y_2)) -> c_34()
  , #eq^#(leaf(), nil()) -> c_35()
  , #eq^#(leaf(), leaf()) -> c_36()
  , #eq^#(leaf(), node(@y_1, @y_2, @y_3)) -> c_37()
  , #eq^#(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2)) -> c_38()
  , #eq^#(node(@x_1, @x_2, @x_3), nil()) -> c_39()
  , #eq^#(node(@x_1, @x_2, @x_3), leaf()) -> c_40()
  , #eq^#(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) ->
    c_41(#and^#(#eq(@x_1, @y_1),
                #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3))),
         #eq^#(@x_1, @y_1),
         #and^#(#eq(@x_2, @y_2), #eq(@x_3, @y_3)),
         #eq^#(@x_2, @y_2),
         #eq^#(@x_3, @y_3))
  , #eq^#(#0(), #0()) -> c_42()
  , #eq^#(#0(), #neg(@y)) -> c_43()
  , #eq^#(#0(), #pos(@y)) -> c_44()
  , #eq^#(#0(), #s(@y)) -> c_45()
  , #eq^#(#neg(@x), #0()) -> c_46()
  , #eq^#(#neg(@x), #neg(@y)) -> c_47(#eq^#(@x, @y))
  , #eq^#(#neg(@x), #pos(@y)) -> c_48()
  , #eq^#(#pos(@x), #0()) -> c_49()
  , #eq^#(#pos(@x), #neg(@y)) -> c_50()
  , #eq^#(#pos(@x), #pos(@y)) -> c_51(#eq^#(@x, @y))
  , #eq^#(#s(@x), #0()) -> c_52()
  , #eq^#(#s(@x), #s(@y)) -> c_53(#eq^#(@x, @y))
  , appendreverse#1^#(nil(), @sofar) -> c_4()
  , bfs#2^#(nil(), @x) -> c_11()
  , bfs#4^#(#true(), @futurequeue, @t1, @t2, @ts, @x, @y) -> c_14()
  , dfs#1^#(nil(), @x) -> c_20()
  , dfs#3^#(#true(), @t, @t1, @t2, @ts, @x) -> c_24()
  , #and^#(#false(), #false()) -> c_54()
  , #and^#(#false(), #true()) -> c_55()
  , #and^#(#true(), #false()) -> c_56()
  , #and^#(#true(), #true()) -> c_57() }
Weak Trs:
  { #equal(@x, @y) -> #eq(@x, @y)
  , #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
    #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
  , #eq(::(@x_1, @x_2), nil()) -> #false()
  , #eq(::(@x_1, @x_2), leaf()) -> #false()
  , #eq(::(@x_1, @x_2), node(@y_1, @y_2, @y_3)) -> #false()
  , #eq(nil(), ::(@y_1, @y_2)) -> #false()
  , #eq(nil(), nil()) -> #true()
  , #eq(nil(), leaf()) -> #false()
  , #eq(nil(), node(@y_1, @y_2, @y_3)) -> #false()
  , #eq(leaf(), ::(@y_1, @y_2)) -> #false()
  , #eq(leaf(), nil()) -> #false()
  , #eq(leaf(), leaf()) -> #true()
  , #eq(leaf(), node(@y_1, @y_2, @y_3)) -> #false()
  , #eq(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2)) -> #false()
  , #eq(node(@x_1, @x_2, @x_3), nil()) -> #false()
  , #eq(node(@x_1, @x_2, @x_3), leaf()) -> #false()
  , #eq(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) ->
    #and(#eq(@x_1, @y_1), #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3)))
  , #eq(#0(), #0()) -> #true()
  , #eq(#0(), #neg(@y)) -> #false()
  , #eq(#0(), #pos(@y)) -> #false()
  , #eq(#0(), #s(@y)) -> #false()
  , #eq(#neg(@x), #0()) -> #false()
  , #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
  , #eq(#neg(@x), #pos(@y)) -> #false()
  , #eq(#pos(@x), #0()) -> #false()
  , #eq(#pos(@x), #neg(@y)) -> #false()
  , #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
  , #eq(#s(@x), #0()) -> #false()
  , #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
  , appendreverse(@toreverse, @sofar) ->
    appendreverse#1(@toreverse, @sofar)
  , appendreverse#1(::(@a, @as), @sofar) ->
    appendreverse(@as, ::(@a, @sofar))
  , appendreverse#1(nil(), @sofar) -> @sofar
  , bfs(@queue, @futurequeue, @x) -> bfs#1(@queue, @futurequeue, @x)
  , bfs#1(::(@t, @ts), @futurequeue, @x) ->
    bfs#3(@t, @futurequeue, @ts, @x)
  , bfs#1(nil(), @futurequeue, @x) -> bfs#2(@futurequeue, @x)
  , bfs#3(leaf(), @futurequeue, @ts, @x) ->
    bfs(@ts, @futurequeue, @x)
  , bfs#3(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
    bfs#4(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y)
  , bfs#2(::(@t, @ts), @x) -> bfs(reverse(::(@t, @ts)), nil(), @x)
  , bfs#2(nil(), @x) -> leaf()
  , reverse(@xs) -> appendreverse(@xs, nil())
  , bfs#4(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
    bfs(@ts, ::(@t2, ::(@t1, @futurequeue)), @x)
  , bfs#4(#true(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
    node(@y, @t1, @t2)
  , bfs2(@t, @x) -> bfs2#1(dobfs(@t, @x), @x)
  , dobfs(@t, @x) -> bfs(::(@t, nil()), nil(), @x)
  , bfs2#1(@t', @x) -> dobfs(@t', @x)
  , dfs(@queue, @x) -> dfs#1(@queue, @x)
  , dfs#1(::(@t, @ts), @x) -> dfs#2(@t, @t, @ts, @x)
  , dfs#1(nil(), @x) -> leaf()
  , dfs#2(leaf(), @t, @ts, @x) -> dfs(@ts, @x)
  , dfs#2(node(@a, @t1, @t2), @t, @ts, @x) ->
    dfs#3(#equal(@a, @x), @t, @t1, @t2, @ts, @x)
  , dfs#3(#false(), @t, @t1, @t2, @ts, @x) ->
    dfs(::(@t1, ::(@t2, @ts)), @x)
  , dfs#3(#true(), @t, @t1, @t2, @ts, @x) -> @t
  , dodfs(@t, @x) -> dfs(::(@t, nil()), @x)
  , #and(#false(), #false()) -> #false()
  , #and(#false(), #true()) -> #false()
  , #and(#true(), #false()) -> #false()
  , #and(#true(), #true()) -> #true() }
Obligation:
  innermost runtime complexity
Answer:
  YES(O(1),O(n^2))

The following weak DPs constitute a sub-graph of the DG that is
closed under successors. The DPs are removed.

{ #equal^#(@x, @y) -> c_1(#eq^#(@x, @y))
, #eq^#(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
  c_26(#and^#(#eq(@x_1, @y_1), #eq(@x_2, @y_2)),
       #eq^#(@x_1, @y_1),
       #eq^#(@x_2, @y_2))
, #eq^#(::(@x_1, @x_2), nil()) -> c_27()
, #eq^#(::(@x_1, @x_2), leaf()) -> c_28()
, #eq^#(::(@x_1, @x_2), node(@y_1, @y_2, @y_3)) -> c_29()
, #eq^#(nil(), ::(@y_1, @y_2)) -> c_30()
, #eq^#(nil(), nil()) -> c_31()
, #eq^#(nil(), leaf()) -> c_32()
, #eq^#(nil(), node(@y_1, @y_2, @y_3)) -> c_33()
, #eq^#(leaf(), ::(@y_1, @y_2)) -> c_34()
, #eq^#(leaf(), nil()) -> c_35()
, #eq^#(leaf(), leaf()) -> c_36()
, #eq^#(leaf(), node(@y_1, @y_2, @y_3)) -> c_37()
, #eq^#(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2)) -> c_38()
, #eq^#(node(@x_1, @x_2, @x_3), nil()) -> c_39()
, #eq^#(node(@x_1, @x_2, @x_3), leaf()) -> c_40()
, #eq^#(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) ->
  c_41(#and^#(#eq(@x_1, @y_1),
              #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3))),
       #eq^#(@x_1, @y_1),
       #and^#(#eq(@x_2, @y_2), #eq(@x_3, @y_3)),
       #eq^#(@x_2, @y_2),
       #eq^#(@x_3, @y_3))
, #eq^#(#0(), #0()) -> c_42()
, #eq^#(#0(), #neg(@y)) -> c_43()
, #eq^#(#0(), #pos(@y)) -> c_44()
, #eq^#(#0(), #s(@y)) -> c_45()
, #eq^#(#neg(@x), #0()) -> c_46()
, #eq^#(#neg(@x), #neg(@y)) -> c_47(#eq^#(@x, @y))
, #eq^#(#neg(@x), #pos(@y)) -> c_48()
, #eq^#(#pos(@x), #0()) -> c_49()
, #eq^#(#pos(@x), #neg(@y)) -> c_50()
, #eq^#(#pos(@x), #pos(@y)) -> c_51(#eq^#(@x, @y))
, #eq^#(#s(@x), #0()) -> c_52()
, #eq^#(#s(@x), #s(@y)) -> c_53(#eq^#(@x, @y))
, appendreverse#1^#(nil(), @sofar) -> c_4()
, bfs#2^#(nil(), @x) -> c_11()
, bfs#4^#(#true(), @futurequeue, @t1, @t2, @ts, @x, @y) -> c_14()
, dfs#1^#(nil(), @x) -> c_20()
, dfs#3^#(#true(), @t, @t1, @t2, @ts, @x) -> c_24()
, #and^#(#false(), #false()) -> c_54()
, #and^#(#false(), #true()) -> c_55()
, #and^#(#true(), #false()) -> c_56()
, #and^#(#true(), #true()) -> c_57() }

We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^2)).

Strict DPs:
  { appendreverse^#(@toreverse, @sofar) ->
    c_2(appendreverse#1^#(@toreverse, @sofar))
  , appendreverse#1^#(::(@a, @as), @sofar) ->
    c_3(appendreverse^#(@as, ::(@a, @sofar)))
  , bfs^#(@queue, @futurequeue, @x) ->
    c_5(bfs#1^#(@queue, @futurequeue, @x))
  , bfs#1^#(::(@t, @ts), @futurequeue, @x) ->
    c_6(bfs#3^#(@t, @futurequeue, @ts, @x))
  , bfs#1^#(nil(), @futurequeue, @x) ->
    c_7(bfs#2^#(@futurequeue, @x))
  , bfs#3^#(leaf(), @futurequeue, @ts, @x) ->
    c_8(bfs^#(@ts, @futurequeue, @x))
  , bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
    c_9(bfs#4^#(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y),
        #equal^#(@x, @y))
  , bfs#2^#(::(@t, @ts), @x) ->
    c_10(bfs^#(reverse(::(@t, @ts)), nil(), @x),
         reverse^#(::(@t, @ts)))
  , bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
    c_13(bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x))
  , reverse^#(@xs) -> c_12(appendreverse^#(@xs, nil()))
  , bfs2^#(@t, @x) ->
    c_15(bfs2#1^#(dobfs(@t, @x), @x), dobfs^#(@t, @x))
  , bfs2#1^#(@t', @x) -> c_17(dobfs^#(@t', @x))
  , dobfs^#(@t, @x) -> c_16(bfs^#(::(@t, nil()), nil(), @x))
  , dfs^#(@queue, @x) -> c_18(dfs#1^#(@queue, @x))
  , dfs#1^#(::(@t, @ts), @x) -> c_19(dfs#2^#(@t, @t, @ts, @x))
  , dfs#2^#(leaf(), @t, @ts, @x) -> c_21(dfs^#(@ts, @x))
  , dfs#2^#(node(@a, @t1, @t2), @t, @ts, @x) ->
    c_22(dfs#3^#(#equal(@a, @x), @t, @t1, @t2, @ts, @x),
         #equal^#(@a, @x))
  , dfs#3^#(#false(), @t, @t1, @t2, @ts, @x) ->
    c_23(dfs^#(::(@t1, ::(@t2, @ts)), @x)) }
Weak Trs:
  { #equal(@x, @y) -> #eq(@x, @y)
  , #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
    #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
  , #eq(::(@x_1, @x_2), nil()) -> #false()
  , #eq(::(@x_1, @x_2), leaf()) -> #false()
  , #eq(::(@x_1, @x_2), node(@y_1, @y_2, @y_3)) -> #false()
  , #eq(nil(), ::(@y_1, @y_2)) -> #false()
  , #eq(nil(), nil()) -> #true()
  , #eq(nil(), leaf()) -> #false()
  , #eq(nil(), node(@y_1, @y_2, @y_3)) -> #false()
  , #eq(leaf(), ::(@y_1, @y_2)) -> #false()
  , #eq(leaf(), nil()) -> #false()
  , #eq(leaf(), leaf()) -> #true()
  , #eq(leaf(), node(@y_1, @y_2, @y_3)) -> #false()
  , #eq(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2)) -> #false()
  , #eq(node(@x_1, @x_2, @x_3), nil()) -> #false()
  , #eq(node(@x_1, @x_2, @x_3), leaf()) -> #false()
  , #eq(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) ->
    #and(#eq(@x_1, @y_1), #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3)))
  , #eq(#0(), #0()) -> #true()
  , #eq(#0(), #neg(@y)) -> #false()
  , #eq(#0(), #pos(@y)) -> #false()
  , #eq(#0(), #s(@y)) -> #false()
  , #eq(#neg(@x), #0()) -> #false()
  , #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
  , #eq(#neg(@x), #pos(@y)) -> #false()
  , #eq(#pos(@x), #0()) -> #false()
  , #eq(#pos(@x), #neg(@y)) -> #false()
  , #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
  , #eq(#s(@x), #0()) -> #false()
  , #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
  , appendreverse(@toreverse, @sofar) ->
    appendreverse#1(@toreverse, @sofar)
  , appendreverse#1(::(@a, @as), @sofar) ->
    appendreverse(@as, ::(@a, @sofar))
  , appendreverse#1(nil(), @sofar) -> @sofar
  , bfs(@queue, @futurequeue, @x) -> bfs#1(@queue, @futurequeue, @x)
  , bfs#1(::(@t, @ts), @futurequeue, @x) ->
    bfs#3(@t, @futurequeue, @ts, @x)
  , bfs#1(nil(), @futurequeue, @x) -> bfs#2(@futurequeue, @x)
  , bfs#3(leaf(), @futurequeue, @ts, @x) ->
    bfs(@ts, @futurequeue, @x)
  , bfs#3(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
    bfs#4(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y)
  , bfs#2(::(@t, @ts), @x) -> bfs(reverse(::(@t, @ts)), nil(), @x)
  , bfs#2(nil(), @x) -> leaf()
  , reverse(@xs) -> appendreverse(@xs, nil())
  , bfs#4(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
    bfs(@ts, ::(@t2, ::(@t1, @futurequeue)), @x)
  , bfs#4(#true(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
    node(@y, @t1, @t2)
  , bfs2(@t, @x) -> bfs2#1(dobfs(@t, @x), @x)
  , dobfs(@t, @x) -> bfs(::(@t, nil()), nil(), @x)
  , bfs2#1(@t', @x) -> dobfs(@t', @x)
  , dfs(@queue, @x) -> dfs#1(@queue, @x)
  , dfs#1(::(@t, @ts), @x) -> dfs#2(@t, @t, @ts, @x)
  , dfs#1(nil(), @x) -> leaf()
  , dfs#2(leaf(), @t, @ts, @x) -> dfs(@ts, @x)
  , dfs#2(node(@a, @t1, @t2), @t, @ts, @x) ->
    dfs#3(#equal(@a, @x), @t, @t1, @t2, @ts, @x)
  , dfs#3(#false(), @t, @t1, @t2, @ts, @x) ->
    dfs(::(@t1, ::(@t2, @ts)), @x)
  , dfs#3(#true(), @t, @t1, @t2, @ts, @x) -> @t
  , dodfs(@t, @x) -> dfs(::(@t, nil()), @x)
  , #and(#false(), #false()) -> #false()
  , #and(#false(), #true()) -> #false()
  , #and(#true(), #false()) -> #false()
  , #and(#true(), #true()) -> #true() }
Obligation:
  innermost runtime complexity
Answer:
  YES(O(1),O(n^2))

Due to missing edges in the dependency-graph, the right-hand sides
of following rules could be simplified:

  { bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
    c_9(bfs#4^#(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y),
        #equal^#(@x, @y))
  , dfs#2^#(node(@a, @t1, @t2), @t, @ts, @x) ->
    c_22(dfs#3^#(#equal(@a, @x), @t, @t1, @t2, @ts, @x),
         #equal^#(@a, @x)) }

We are left with following problem, upon which TcT provides the
certificate YES(O(1),O(n^2)).

Strict DPs:
  { appendreverse^#(@toreverse, @sofar) ->
    c_1(appendreverse#1^#(@toreverse, @sofar))
  , appendreverse#1^#(::(@a, @as), @sofar) ->
    c_2(appendreverse^#(@as, ::(@a, @sofar)))
  , bfs^#(@queue, @futurequeue, @x) ->
    c_3(bfs#1^#(@queue, @futurequeue, @x))
  , bfs#1^#(::(@t, @ts), @futurequeue, @x) ->
    c_4(bfs#3^#(@t, @futurequeue, @ts, @x))
  , bfs#1^#(nil(), @futurequeue, @x) ->
    c_5(bfs#2^#(@futurequeue, @x))
  , bfs#3^#(leaf(), @futurequeue, @ts, @x) ->
    c_6(bfs^#(@ts, @futurequeue, @x))
  , bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
    c_7(bfs#4^#(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y))
  , bfs#2^#(::(@t, @ts), @x) ->
    c_8(bfs^#(reverse(::(@t, @ts)), nil(), @x), reverse^#(::(@t, @ts)))
  , bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
    c_9(bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x))
  , reverse^#(@xs) -> c_10(appendreverse^#(@xs, nil()))
  , bfs2^#(@t, @x) ->
    c_11(bfs2#1^#(dobfs(@t, @x), @x), dobfs^#(@t, @x))
  , bfs2#1^#(@t', @x) -> c_12(dobfs^#(@t', @x))
  , dobfs^#(@t, @x) -> c_13(bfs^#(::(@t, nil()), nil(), @x))
  , dfs^#(@queue, @x) -> c_14(dfs#1^#(@queue, @x))
  , dfs#1^#(::(@t, @ts), @x) -> c_15(dfs#2^#(@t, @t, @ts, @x))
  , dfs#2^#(leaf(), @t, @ts, @x) -> c_16(dfs^#(@ts, @x))
  , dfs#2^#(node(@a, @t1, @t2), @t, @ts, @x) ->
    c_17(dfs#3^#(#equal(@a, @x), @t, @t1, @t2, @ts, @x))
  , dfs#3^#(#false(), @t, @t1, @t2, @ts, @x) ->
    c_18(dfs^#(::(@t1, ::(@t2, @ts)), @x)) }
Weak Trs:
  { #equal(@x, @y) -> #eq(@x, @y)
  , #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
    #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
  , #eq(::(@x_1, @x_2), nil()) -> #false()
  , #eq(::(@x_1, @x_2), leaf()) -> #false()
  , #eq(::(@x_1, @x_2), node(@y_1, @y_2, @y_3)) -> #false()
  , #eq(nil(), ::(@y_1, @y_2)) -> #false()
  , #eq(nil(), nil()) -> #true()
  , #eq(nil(), leaf()) -> #false()
  , #eq(nil(), node(@y_1, @y_2, @y_3)) -> #false()
  , #eq(leaf(), ::(@y_1, @y_2)) -> #false()
  , #eq(leaf(), nil()) -> #false()
  , #eq(leaf(), leaf()) -> #true()
  , #eq(leaf(), node(@y_1, @y_2, @y_3)) -> #false()
  , #eq(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2)) -> #false()
  , #eq(node(@x_1, @x_2, @x_3), nil()) -> #false()
  , #eq(node(@x_1, @x_2, @x_3), leaf()) -> #false()
  , #eq(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) ->
    #and(#eq(@x_1, @y_1), #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3)))
  , #eq(#0(), #0()) -> #true()
  , #eq(#0(), #neg(@y)) -> #false()
  , #eq(#0(), #pos(@y)) -> #false()
  , #eq(#0(), #s(@y)) -> #false()
  , #eq(#neg(@x), #0()) -> #false()
  , #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
  , #eq(#neg(@x), #pos(@y)) -> #false()
  , #eq(#pos(@x), #0()) -> #false()
  , #eq(#pos(@x), #neg(@y)) -> #false()
  , #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
  , #eq(#s(@x), #0()) -> #false()
  , #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
  , appendreverse(@toreverse, @sofar) ->
    appendreverse#1(@toreverse, @sofar)
  , appendreverse#1(::(@a, @as), @sofar) ->
    appendreverse(@as, ::(@a, @sofar))
  , appendreverse#1(nil(), @sofar) -> @sofar
  , bfs(@queue, @futurequeue, @x) -> bfs#1(@queue, @futurequeue, @x)
  , bfs#1(::(@t, @ts), @futurequeue, @x) ->
    bfs#3(@t, @futurequeue, @ts, @x)
  , bfs#1(nil(), @futurequeue, @x) -> bfs#2(@futurequeue, @x)
  , bfs#3(leaf(), @futurequeue, @ts, @x) ->
    bfs(@ts, @futurequeue, @x)
  , bfs#3(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
    bfs#4(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y)
  , bfs#2(::(@t, @ts), @x) -> bfs(reverse(::(@t, @ts)), nil(), @x)
  , bfs#2(nil(), @x) -> leaf()
  , reverse(@xs) -> appendreverse(@xs, nil())
  , bfs#4(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
    bfs(@ts, ::(@t2, ::(@t1, @futurequeue)), @x)
  , bfs#4(#true(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
    node(@y, @t1, @t2)
  , bfs2(@t, @x) -> bfs2#1(dobfs(@t, @x), @x)
  , dobfs(@t, @x) -> bfs(::(@t, nil()), nil(), @x)
  , bfs2#1(@t', @x) -> dobfs(@t', @x)
  , dfs(@queue, @x) -> dfs#1(@queue, @x)
  , dfs#1(::(@t, @ts), @x) -> dfs#2(@t, @t, @ts, @x)
  , dfs#1(nil(), @x) -> leaf()
  , dfs#2(leaf(), @t, @ts, @x) -> dfs(@ts, @x)
  , dfs#2(node(@a, @t1, @t2), @t, @ts, @x) ->
    dfs#3(#equal(@a, @x), @t, @t1, @t2, @ts, @x)
  , dfs#3(#false(), @t, @t1, @t2, @ts, @x) ->
    dfs(::(@t1, ::(@t2, @ts)), @x)
  , dfs#3(#true(), @t, @t1, @t2, @ts, @x) -> @t
  , dodfs(@t, @x) -> dfs(::(@t, nil()), @x)
  , #and(#false(), #false()) -> #false()
  , #and(#false(), #true()) -> #false()
  , #and(#true(), #false()) -> #false()
  , #and(#true(), #true()) -> #true() }
Obligation:
  innermost runtime complexity
Answer:
  YES(O(1),O(n^2))

We analyse the complexity of following sub-problems (R) and (S).
Problem (S) is obtained from the input problem by shifting strict
rules from (R) into the weak component:

Problem (R):
------------
  Strict DPs:
    { appendreverse^#(@toreverse, @sofar) ->
      c_1(appendreverse#1^#(@toreverse, @sofar))
    , appendreverse#1^#(::(@a, @as), @sofar) ->
      c_2(appendreverse^#(@as, ::(@a, @sofar)))
    , bfs^#(@queue, @futurequeue, @x) ->
      c_3(bfs#1^#(@queue, @futurequeue, @x))
    , bfs#1^#(::(@t, @ts), @futurequeue, @x) ->
      c_4(bfs#3^#(@t, @futurequeue, @ts, @x))
    , bfs#1^#(nil(), @futurequeue, @x) ->
      c_5(bfs#2^#(@futurequeue, @x))
    , bfs#3^#(leaf(), @futurequeue, @ts, @x) ->
      c_6(bfs^#(@ts, @futurequeue, @x))
    , bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
      c_7(bfs#4^#(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y))
    , bfs#2^#(::(@t, @ts), @x) ->
      c_8(bfs^#(reverse(::(@t, @ts)), nil(), @x), reverse^#(::(@t, @ts)))
    , bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
      c_9(bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x))
    , reverse^#(@xs) -> c_10(appendreverse^#(@xs, nil()))
    , bfs2^#(@t, @x) ->
      c_11(bfs2#1^#(dobfs(@t, @x), @x), dobfs^#(@t, @x))
    , bfs2#1^#(@t', @x) -> c_12(dobfs^#(@t', @x))
    , dobfs^#(@t, @x) -> c_13(bfs^#(::(@t, nil()), nil(), @x)) }
  Weak DPs:
    { dfs^#(@queue, @x) -> c_14(dfs#1^#(@queue, @x))
    , dfs#1^#(::(@t, @ts), @x) -> c_15(dfs#2^#(@t, @t, @ts, @x))
    , dfs#2^#(leaf(), @t, @ts, @x) -> c_16(dfs^#(@ts, @x))
    , dfs#2^#(node(@a, @t1, @t2), @t, @ts, @x) ->
      c_17(dfs#3^#(#equal(@a, @x), @t, @t1, @t2, @ts, @x))
    , dfs#3^#(#false(), @t, @t1, @t2, @ts, @x) ->
      c_18(dfs^#(::(@t1, ::(@t2, @ts)), @x)) }
  Weak Trs:
    { #equal(@x, @y) -> #eq(@x, @y)
    , #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
      #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
    , #eq(::(@x_1, @x_2), nil()) -> #false()
    , #eq(::(@x_1, @x_2), leaf()) -> #false()
    , #eq(::(@x_1, @x_2), node(@y_1, @y_2, @y_3)) -> #false()
    , #eq(nil(), ::(@y_1, @y_2)) -> #false()
    , #eq(nil(), nil()) -> #true()
    , #eq(nil(), leaf()) -> #false()
    , #eq(nil(), node(@y_1, @y_2, @y_3)) -> #false()
    , #eq(leaf(), ::(@y_1, @y_2)) -> #false()
    , #eq(leaf(), nil()) -> #false()
    , #eq(leaf(), leaf()) -> #true()
    , #eq(leaf(), node(@y_1, @y_2, @y_3)) -> #false()
    , #eq(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2)) -> #false()
    , #eq(node(@x_1, @x_2, @x_3), nil()) -> #false()
    , #eq(node(@x_1, @x_2, @x_3), leaf()) -> #false()
    , #eq(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) ->
      #and(#eq(@x_1, @y_1), #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3)))
    , #eq(#0(), #0()) -> #true()
    , #eq(#0(), #neg(@y)) -> #false()
    , #eq(#0(), #pos(@y)) -> #false()
    , #eq(#0(), #s(@y)) -> #false()
    , #eq(#neg(@x), #0()) -> #false()
    , #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
    , #eq(#neg(@x), #pos(@y)) -> #false()
    , #eq(#pos(@x), #0()) -> #false()
    , #eq(#pos(@x), #neg(@y)) -> #false()
    , #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
    , #eq(#s(@x), #0()) -> #false()
    , #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
    , appendreverse(@toreverse, @sofar) ->
      appendreverse#1(@toreverse, @sofar)
    , appendreverse#1(::(@a, @as), @sofar) ->
      appendreverse(@as, ::(@a, @sofar))
    , appendreverse#1(nil(), @sofar) -> @sofar
    , bfs(@queue, @futurequeue, @x) -> bfs#1(@queue, @futurequeue, @x)
    , bfs#1(::(@t, @ts), @futurequeue, @x) ->
      bfs#3(@t, @futurequeue, @ts, @x)
    , bfs#1(nil(), @futurequeue, @x) -> bfs#2(@futurequeue, @x)
    , bfs#3(leaf(), @futurequeue, @ts, @x) ->
      bfs(@ts, @futurequeue, @x)
    , bfs#3(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
      bfs#4(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y)
    , bfs#2(::(@t, @ts), @x) -> bfs(reverse(::(@t, @ts)), nil(), @x)
    , bfs#2(nil(), @x) -> leaf()
    , reverse(@xs) -> appendreverse(@xs, nil())
    , bfs#4(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
      bfs(@ts, ::(@t2, ::(@t1, @futurequeue)), @x)
    , bfs#4(#true(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
      node(@y, @t1, @t2)
    , bfs2(@t, @x) -> bfs2#1(dobfs(@t, @x), @x)
    , dobfs(@t, @x) -> bfs(::(@t, nil()), nil(), @x)
    , bfs2#1(@t', @x) -> dobfs(@t', @x)
    , dfs(@queue, @x) -> dfs#1(@queue, @x)
    , dfs#1(::(@t, @ts), @x) -> dfs#2(@t, @t, @ts, @x)
    , dfs#1(nil(), @x) -> leaf()
    , dfs#2(leaf(), @t, @ts, @x) -> dfs(@ts, @x)
    , dfs#2(node(@a, @t1, @t2), @t, @ts, @x) ->
      dfs#3(#equal(@a, @x), @t, @t1, @t2, @ts, @x)
    , dfs#3(#false(), @t, @t1, @t2, @ts, @x) ->
      dfs(::(@t1, ::(@t2, @ts)), @x)
    , dfs#3(#true(), @t, @t1, @t2, @ts, @x) -> @t
    , dodfs(@t, @x) -> dfs(::(@t, nil()), @x)
    , #and(#false(), #false()) -> #false()
    , #and(#false(), #true()) -> #false()
    , #and(#true(), #false()) -> #false()
    , #and(#true(), #true()) -> #true() }
  StartTerms: basic terms
  Strategy: innermost

Problem (S):
------------
  Strict DPs:
    { dfs^#(@queue, @x) -> c_14(dfs#1^#(@queue, @x))
    , dfs#1^#(::(@t, @ts), @x) -> c_15(dfs#2^#(@t, @t, @ts, @x))
    , dfs#2^#(leaf(), @t, @ts, @x) -> c_16(dfs^#(@ts, @x))
    , dfs#2^#(node(@a, @t1, @t2), @t, @ts, @x) ->
      c_17(dfs#3^#(#equal(@a, @x), @t, @t1, @t2, @ts, @x))
    , dfs#3^#(#false(), @t, @t1, @t2, @ts, @x) ->
      c_18(dfs^#(::(@t1, ::(@t2, @ts)), @x)) }
  Weak DPs:
    { appendreverse^#(@toreverse, @sofar) ->
      c_1(appendreverse#1^#(@toreverse, @sofar))
    , appendreverse#1^#(::(@a, @as), @sofar) ->
      c_2(appendreverse^#(@as, ::(@a, @sofar)))
    , bfs^#(@queue, @futurequeue, @x) ->
      c_3(bfs#1^#(@queue, @futurequeue, @x))
    , bfs#1^#(::(@t, @ts), @futurequeue, @x) ->
      c_4(bfs#3^#(@t, @futurequeue, @ts, @x))
    , bfs#1^#(nil(), @futurequeue, @x) ->
      c_5(bfs#2^#(@futurequeue, @x))
    , bfs#3^#(leaf(), @futurequeue, @ts, @x) ->
      c_6(bfs^#(@ts, @futurequeue, @x))
    , bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
      c_7(bfs#4^#(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y))
    , bfs#2^#(::(@t, @ts), @x) ->
      c_8(bfs^#(reverse(::(@t, @ts)), nil(), @x), reverse^#(::(@t, @ts)))
    , bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
      c_9(bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x))
    , reverse^#(@xs) -> c_10(appendreverse^#(@xs, nil()))
    , bfs2^#(@t, @x) ->
      c_11(bfs2#1^#(dobfs(@t, @x), @x), dobfs^#(@t, @x))
    , bfs2#1^#(@t', @x) -> c_12(dobfs^#(@t', @x))
    , dobfs^#(@t, @x) -> c_13(bfs^#(::(@t, nil()), nil(), @x)) }
  Weak Trs:
    { #equal(@x, @y) -> #eq(@x, @y)
    , #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
      #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
    , #eq(::(@x_1, @x_2), nil()) -> #false()
    , #eq(::(@x_1, @x_2), leaf()) -> #false()
    , #eq(::(@x_1, @x_2), node(@y_1, @y_2, @y_3)) -> #false()
    , #eq(nil(), ::(@y_1, @y_2)) -> #false()
    , #eq(nil(), nil()) -> #true()
    , #eq(nil(), leaf()) -> #false()
    , #eq(nil(), node(@y_1, @y_2, @y_3)) -> #false()
    , #eq(leaf(), ::(@y_1, @y_2)) -> #false()
    , #eq(leaf(), nil()) -> #false()
    , #eq(leaf(), leaf()) -> #true()
    , #eq(leaf(), node(@y_1, @y_2, @y_3)) -> #false()
    , #eq(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2)) -> #false()
    , #eq(node(@x_1, @x_2, @x_3), nil()) -> #false()
    , #eq(node(@x_1, @x_2, @x_3), leaf()) -> #false()
    , #eq(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) ->
      #and(#eq(@x_1, @y_1), #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3)))
    , #eq(#0(), #0()) -> #true()
    , #eq(#0(), #neg(@y)) -> #false()
    , #eq(#0(), #pos(@y)) -> #false()
    , #eq(#0(), #s(@y)) -> #false()
    , #eq(#neg(@x), #0()) -> #false()
    , #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
    , #eq(#neg(@x), #pos(@y)) -> #false()
    , #eq(#pos(@x), #0()) -> #false()
    , #eq(#pos(@x), #neg(@y)) -> #false()
    , #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
    , #eq(#s(@x), #0()) -> #false()
    , #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
    , appendreverse(@toreverse, @sofar) ->
      appendreverse#1(@toreverse, @sofar)
    , appendreverse#1(::(@a, @as), @sofar) ->
      appendreverse(@as, ::(@a, @sofar))
    , appendreverse#1(nil(), @sofar) -> @sofar
    , bfs(@queue, @futurequeue, @x) -> bfs#1(@queue, @futurequeue, @x)
    , bfs#1(::(@t, @ts), @futurequeue, @x) ->
      bfs#3(@t, @futurequeue, @ts, @x)
    , bfs#1(nil(), @futurequeue, @x) -> bfs#2(@futurequeue, @x)
    , bfs#3(leaf(), @futurequeue, @ts, @x) ->
      bfs(@ts, @futurequeue, @x)
    , bfs#3(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
      bfs#4(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y)
    , bfs#2(::(@t, @ts), @x) -> bfs(reverse(::(@t, @ts)), nil(), @x)
    , bfs#2(nil(), @x) -> leaf()
    , reverse(@xs) -> appendreverse(@xs, nil())
    , bfs#4(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
      bfs(@ts, ::(@t2, ::(@t1, @futurequeue)), @x)
    , bfs#4(#true(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
      node(@y, @t1, @t2)
    , bfs2(@t, @x) -> bfs2#1(dobfs(@t, @x), @x)
    , dobfs(@t, @x) -> bfs(::(@t, nil()), nil(), @x)
    , bfs2#1(@t', @x) -> dobfs(@t', @x)
    , dfs(@queue, @x) -> dfs#1(@queue, @x)
    , dfs#1(::(@t, @ts), @x) -> dfs#2(@t, @t, @ts, @x)
    , dfs#1(nil(), @x) -> leaf()
    , dfs#2(leaf(), @t, @ts, @x) -> dfs(@ts, @x)
    , dfs#2(node(@a, @t1, @t2), @t, @ts, @x) ->
      dfs#3(#equal(@a, @x), @t, @t1, @t2, @ts, @x)
    , dfs#3(#false(), @t, @t1, @t2, @ts, @x) ->
      dfs(::(@t1, ::(@t2, @ts)), @x)
    , dfs#3(#true(), @t, @t1, @t2, @ts, @x) -> @t
    , dodfs(@t, @x) -> dfs(::(@t, nil()), @x)
    , #and(#false(), #false()) -> #false()
    , #and(#false(), #true()) -> #false()
    , #and(#true(), #false()) -> #false()
    , #and(#true(), #true()) -> #true() }
  StartTerms: basic terms
  Strategy: innermost

Overall, the transformation results in the following sub-problem(s):

Generated new problems:
-----------------------
R) Strict DPs:
     { appendreverse^#(@toreverse, @sofar) ->
       c_1(appendreverse#1^#(@toreverse, @sofar))
     , appendreverse#1^#(::(@a, @as), @sofar) ->
       c_2(appendreverse^#(@as, ::(@a, @sofar)))
     , bfs^#(@queue, @futurequeue, @x) ->
       c_3(bfs#1^#(@queue, @futurequeue, @x))
     , bfs#1^#(::(@t, @ts), @futurequeue, @x) ->
       c_4(bfs#3^#(@t, @futurequeue, @ts, @x))
     , bfs#1^#(nil(), @futurequeue, @x) ->
       c_5(bfs#2^#(@futurequeue, @x))
     , bfs#3^#(leaf(), @futurequeue, @ts, @x) ->
       c_6(bfs^#(@ts, @futurequeue, @x))
     , bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
       c_7(bfs#4^#(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y))
     , bfs#2^#(::(@t, @ts), @x) ->
       c_8(bfs^#(reverse(::(@t, @ts)), nil(), @x), reverse^#(::(@t, @ts)))
     , bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
       c_9(bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x))
     , reverse^#(@xs) -> c_10(appendreverse^#(@xs, nil()))
     , bfs2^#(@t, @x) ->
       c_11(bfs2#1^#(dobfs(@t, @x), @x), dobfs^#(@t, @x))
     , bfs2#1^#(@t', @x) -> c_12(dobfs^#(@t', @x))
     , dobfs^#(@t, @x) -> c_13(bfs^#(::(@t, nil()), nil(), @x)) }
   Weak DPs:
     { dfs^#(@queue, @x) -> c_14(dfs#1^#(@queue, @x))
     , dfs#1^#(::(@t, @ts), @x) -> c_15(dfs#2^#(@t, @t, @ts, @x))
     , dfs#2^#(leaf(), @t, @ts, @x) -> c_16(dfs^#(@ts, @x))
     , dfs#2^#(node(@a, @t1, @t2), @t, @ts, @x) ->
       c_17(dfs#3^#(#equal(@a, @x), @t, @t1, @t2, @ts, @x))
     , dfs#3^#(#false(), @t, @t1, @t2, @ts, @x) ->
       c_18(dfs^#(::(@t1, ::(@t2, @ts)), @x)) }
   Weak Trs:
     { #equal(@x, @y) -> #eq(@x, @y)
     , #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
       #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
     , #eq(::(@x_1, @x_2), nil()) -> #false()
     , #eq(::(@x_1, @x_2), leaf()) -> #false()
     , #eq(::(@x_1, @x_2), node(@y_1, @y_2, @y_3)) -> #false()
     , #eq(nil(), ::(@y_1, @y_2)) -> #false()
     , #eq(nil(), nil()) -> #true()
     , #eq(nil(), leaf()) -> #false()
     , #eq(nil(), node(@y_1, @y_2, @y_3)) -> #false()
     , #eq(leaf(), ::(@y_1, @y_2)) -> #false()
     , #eq(leaf(), nil()) -> #false()
     , #eq(leaf(), leaf()) -> #true()
     , #eq(leaf(), node(@y_1, @y_2, @y_3)) -> #false()
     , #eq(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2)) -> #false()
     , #eq(node(@x_1, @x_2, @x_3), nil()) -> #false()
     , #eq(node(@x_1, @x_2, @x_3), leaf()) -> #false()
     , #eq(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) ->
       #and(#eq(@x_1, @y_1), #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3)))
     , #eq(#0(), #0()) -> #true()
     , #eq(#0(), #neg(@y)) -> #false()
     , #eq(#0(), #pos(@y)) -> #false()
     , #eq(#0(), #s(@y)) -> #false()
     , #eq(#neg(@x), #0()) -> #false()
     , #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
     , #eq(#neg(@x), #pos(@y)) -> #false()
     , #eq(#pos(@x), #0()) -> #false()
     , #eq(#pos(@x), #neg(@y)) -> #false()
     , #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
     , #eq(#s(@x), #0()) -> #false()
     , #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
     , appendreverse(@toreverse, @sofar) ->
       appendreverse#1(@toreverse, @sofar)
     , appendreverse#1(::(@a, @as), @sofar) ->
       appendreverse(@as, ::(@a, @sofar))
     , appendreverse#1(nil(), @sofar) -> @sofar
     , bfs(@queue, @futurequeue, @x) -> bfs#1(@queue, @futurequeue, @x)
     , bfs#1(::(@t, @ts), @futurequeue, @x) ->
       bfs#3(@t, @futurequeue, @ts, @x)
     , bfs#1(nil(), @futurequeue, @x) -> bfs#2(@futurequeue, @x)
     , bfs#3(leaf(), @futurequeue, @ts, @x) ->
       bfs(@ts, @futurequeue, @x)
     , bfs#3(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
       bfs#4(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y)
     , bfs#2(::(@t, @ts), @x) -> bfs(reverse(::(@t, @ts)), nil(), @x)
     , bfs#2(nil(), @x) -> leaf()
     , reverse(@xs) -> appendreverse(@xs, nil())
     , bfs#4(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
       bfs(@ts, ::(@t2, ::(@t1, @futurequeue)), @x)
     , bfs#4(#true(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
       node(@y, @t1, @t2)
     , bfs2(@t, @x) -> bfs2#1(dobfs(@t, @x), @x)
     , dobfs(@t, @x) -> bfs(::(@t, nil()), nil(), @x)
     , bfs2#1(@t', @x) -> dobfs(@t', @x)
     , dfs(@queue, @x) -> dfs#1(@queue, @x)
     , dfs#1(::(@t, @ts), @x) -> dfs#2(@t, @t, @ts, @x)
     , dfs#1(nil(), @x) -> leaf()
     , dfs#2(leaf(), @t, @ts, @x) -> dfs(@ts, @x)
     , dfs#2(node(@a, @t1, @t2), @t, @ts, @x) ->
       dfs#3(#equal(@a, @x), @t, @t1, @t2, @ts, @x)
     , dfs#3(#false(), @t, @t1, @t2, @ts, @x) ->
       dfs(::(@t1, ::(@t2, @ts)), @x)
     , dfs#3(#true(), @t, @t1, @t2, @ts, @x) -> @t
     , dodfs(@t, @x) -> dfs(::(@t, nil()), @x)
     , #and(#false(), #false()) -> #false()
     , #and(#false(), #true()) -> #false()
     , #and(#true(), #false()) -> #false()
     , #and(#true(), #true()) -> #true() }
   StartTerms: basic terms
   Strategy: innermost
   
   This problem was proven YES(O(1),O(n^2)).

S) Strict DPs:
     { dfs^#(@queue, @x) -> c_14(dfs#1^#(@queue, @x))
     , dfs#1^#(::(@t, @ts), @x) -> c_15(dfs#2^#(@t, @t, @ts, @x))
     , dfs#2^#(leaf(), @t, @ts, @x) -> c_16(dfs^#(@ts, @x))
     , dfs#2^#(node(@a, @t1, @t2), @t, @ts, @x) ->
       c_17(dfs#3^#(#equal(@a, @x), @t, @t1, @t2, @ts, @x))
     , dfs#3^#(#false(), @t, @t1, @t2, @ts, @x) ->
       c_18(dfs^#(::(@t1, ::(@t2, @ts)), @x)) }
   Weak DPs:
     { appendreverse^#(@toreverse, @sofar) ->
       c_1(appendreverse#1^#(@toreverse, @sofar))
     , appendreverse#1^#(::(@a, @as), @sofar) ->
       c_2(appendreverse^#(@as, ::(@a, @sofar)))
     , bfs^#(@queue, @futurequeue, @x) ->
       c_3(bfs#1^#(@queue, @futurequeue, @x))
     , bfs#1^#(::(@t, @ts), @futurequeue, @x) ->
       c_4(bfs#3^#(@t, @futurequeue, @ts, @x))
     , bfs#1^#(nil(), @futurequeue, @x) ->
       c_5(bfs#2^#(@futurequeue, @x))
     , bfs#3^#(leaf(), @futurequeue, @ts, @x) ->
       c_6(bfs^#(@ts, @futurequeue, @x))
     , bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
       c_7(bfs#4^#(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y))
     , bfs#2^#(::(@t, @ts), @x) ->
       c_8(bfs^#(reverse(::(@t, @ts)), nil(), @x), reverse^#(::(@t, @ts)))
     , bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
       c_9(bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x))
     , reverse^#(@xs) -> c_10(appendreverse^#(@xs, nil()))
     , bfs2^#(@t, @x) ->
       c_11(bfs2#1^#(dobfs(@t, @x), @x), dobfs^#(@t, @x))
     , bfs2#1^#(@t', @x) -> c_12(dobfs^#(@t', @x))
     , dobfs^#(@t, @x) -> c_13(bfs^#(::(@t, nil()), nil(), @x)) }
   Weak Trs:
     { #equal(@x, @y) -> #eq(@x, @y)
     , #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
       #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
     , #eq(::(@x_1, @x_2), nil()) -> #false()
     , #eq(::(@x_1, @x_2), leaf()) -> #false()
     , #eq(::(@x_1, @x_2), node(@y_1, @y_2, @y_3)) -> #false()
     , #eq(nil(), ::(@y_1, @y_2)) -> #false()
     , #eq(nil(), nil()) -> #true()
     , #eq(nil(), leaf()) -> #false()
     , #eq(nil(), node(@y_1, @y_2, @y_3)) -> #false()
     , #eq(leaf(), ::(@y_1, @y_2)) -> #false()
     , #eq(leaf(), nil()) -> #false()
     , #eq(leaf(), leaf()) -> #true()
     , #eq(leaf(), node(@y_1, @y_2, @y_3)) -> #false()
     , #eq(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2)) -> #false()
     , #eq(node(@x_1, @x_2, @x_3), nil()) -> #false()
     , #eq(node(@x_1, @x_2, @x_3), leaf()) -> #false()
     , #eq(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) ->
       #and(#eq(@x_1, @y_1), #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3)))
     , #eq(#0(), #0()) -> #true()
     , #eq(#0(), #neg(@y)) -> #false()
     , #eq(#0(), #pos(@y)) -> #false()
     , #eq(#0(), #s(@y)) -> #false()
     , #eq(#neg(@x), #0()) -> #false()
     , #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
     , #eq(#neg(@x), #pos(@y)) -> #false()
     , #eq(#pos(@x), #0()) -> #false()
     , #eq(#pos(@x), #neg(@y)) -> #false()
     , #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
     , #eq(#s(@x), #0()) -> #false()
     , #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
     , appendreverse(@toreverse, @sofar) ->
       appendreverse#1(@toreverse, @sofar)
     , appendreverse#1(::(@a, @as), @sofar) ->
       appendreverse(@as, ::(@a, @sofar))
     , appendreverse#1(nil(), @sofar) -> @sofar
     , bfs(@queue, @futurequeue, @x) -> bfs#1(@queue, @futurequeue, @x)
     , bfs#1(::(@t, @ts), @futurequeue, @x) ->
       bfs#3(@t, @futurequeue, @ts, @x)
     , bfs#1(nil(), @futurequeue, @x) -> bfs#2(@futurequeue, @x)
     , bfs#3(leaf(), @futurequeue, @ts, @x) ->
       bfs(@ts, @futurequeue, @x)
     , bfs#3(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
       bfs#4(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y)
     , bfs#2(::(@t, @ts), @x) -> bfs(reverse(::(@t, @ts)), nil(), @x)
     , bfs#2(nil(), @x) -> leaf()
     , reverse(@xs) -> appendreverse(@xs, nil())
     , bfs#4(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
       bfs(@ts, ::(@t2, ::(@t1, @futurequeue)), @x)
     , bfs#4(#true(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
       node(@y, @t1, @t2)
     , bfs2(@t, @x) -> bfs2#1(dobfs(@t, @x), @x)
     , dobfs(@t, @x) -> bfs(::(@t, nil()), nil(), @x)
     , bfs2#1(@t', @x) -> dobfs(@t', @x)
     , dfs(@queue, @x) -> dfs#1(@queue, @x)
     , dfs#1(::(@t, @ts), @x) -> dfs#2(@t, @t, @ts, @x)
     , dfs#1(nil(), @x) -> leaf()
     , dfs#2(leaf(), @t, @ts, @x) -> dfs(@ts, @x)
     , dfs#2(node(@a, @t1, @t2), @t, @ts, @x) ->
       dfs#3(#equal(@a, @x), @t, @t1, @t2, @ts, @x)
     , dfs#3(#false(), @t, @t1, @t2, @ts, @x) ->
       dfs(::(@t1, ::(@t2, @ts)), @x)
     , dfs#3(#true(), @t, @t1, @t2, @ts, @x) -> @t
     , dodfs(@t, @x) -> dfs(::(@t, nil()), @x)
     , #and(#false(), #false()) -> #false()
     , #and(#false(), #true()) -> #false()
     , #and(#true(), #false()) -> #false()
     , #and(#true(), #true()) -> #true() }
   StartTerms: basic terms
   Strategy: innermost
   
   This problem was proven YES(O(1),O(n^1)).


Proofs for generated problems:
------------------------------
R) We are left with following problem, upon which TcT provides the
   certificate YES(O(1),O(n^2)).
   
   Strict DPs:
     { appendreverse^#(@toreverse, @sofar) ->
       c_1(appendreverse#1^#(@toreverse, @sofar))
     , appendreverse#1^#(::(@a, @as), @sofar) ->
       c_2(appendreverse^#(@as, ::(@a, @sofar)))
     , bfs^#(@queue, @futurequeue, @x) ->
       c_3(bfs#1^#(@queue, @futurequeue, @x))
     , bfs#1^#(::(@t, @ts), @futurequeue, @x) ->
       c_4(bfs#3^#(@t, @futurequeue, @ts, @x))
     , bfs#1^#(nil(), @futurequeue, @x) ->
       c_5(bfs#2^#(@futurequeue, @x))
     , bfs#3^#(leaf(), @futurequeue, @ts, @x) ->
       c_6(bfs^#(@ts, @futurequeue, @x))
     , bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
       c_7(bfs#4^#(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y))
     , bfs#2^#(::(@t, @ts), @x) ->
       c_8(bfs^#(reverse(::(@t, @ts)), nil(), @x), reverse^#(::(@t, @ts)))
     , bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
       c_9(bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x))
     , reverse^#(@xs) -> c_10(appendreverse^#(@xs, nil()))
     , bfs2^#(@t, @x) ->
       c_11(bfs2#1^#(dobfs(@t, @x), @x), dobfs^#(@t, @x))
     , bfs2#1^#(@t', @x) -> c_12(dobfs^#(@t', @x))
     , dobfs^#(@t, @x) -> c_13(bfs^#(::(@t, nil()), nil(), @x)) }
   Weak DPs:
     { dfs^#(@queue, @x) -> c_14(dfs#1^#(@queue, @x))
     , dfs#1^#(::(@t, @ts), @x) -> c_15(dfs#2^#(@t, @t, @ts, @x))
     , dfs#2^#(leaf(), @t, @ts, @x) -> c_16(dfs^#(@ts, @x))
     , dfs#2^#(node(@a, @t1, @t2), @t, @ts, @x) ->
       c_17(dfs#3^#(#equal(@a, @x), @t, @t1, @t2, @ts, @x))
     , dfs#3^#(#false(), @t, @t1, @t2, @ts, @x) ->
       c_18(dfs^#(::(@t1, ::(@t2, @ts)), @x)) }
   Weak Trs:
     { #equal(@x, @y) -> #eq(@x, @y)
     , #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
       #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
     , #eq(::(@x_1, @x_2), nil()) -> #false()
     , #eq(::(@x_1, @x_2), leaf()) -> #false()
     , #eq(::(@x_1, @x_2), node(@y_1, @y_2, @y_3)) -> #false()
     , #eq(nil(), ::(@y_1, @y_2)) -> #false()
     , #eq(nil(), nil()) -> #true()
     , #eq(nil(), leaf()) -> #false()
     , #eq(nil(), node(@y_1, @y_2, @y_3)) -> #false()
     , #eq(leaf(), ::(@y_1, @y_2)) -> #false()
     , #eq(leaf(), nil()) -> #false()
     , #eq(leaf(), leaf()) -> #true()
     , #eq(leaf(), node(@y_1, @y_2, @y_3)) -> #false()
     , #eq(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2)) -> #false()
     , #eq(node(@x_1, @x_2, @x_3), nil()) -> #false()
     , #eq(node(@x_1, @x_2, @x_3), leaf()) -> #false()
     , #eq(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) ->
       #and(#eq(@x_1, @y_1), #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3)))
     , #eq(#0(), #0()) -> #true()
     , #eq(#0(), #neg(@y)) -> #false()
     , #eq(#0(), #pos(@y)) -> #false()
     , #eq(#0(), #s(@y)) -> #false()
     , #eq(#neg(@x), #0()) -> #false()
     , #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
     , #eq(#neg(@x), #pos(@y)) -> #false()
     , #eq(#pos(@x), #0()) -> #false()
     , #eq(#pos(@x), #neg(@y)) -> #false()
     , #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
     , #eq(#s(@x), #0()) -> #false()
     , #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
     , appendreverse(@toreverse, @sofar) ->
       appendreverse#1(@toreverse, @sofar)
     , appendreverse#1(::(@a, @as), @sofar) ->
       appendreverse(@as, ::(@a, @sofar))
     , appendreverse#1(nil(), @sofar) -> @sofar
     , bfs(@queue, @futurequeue, @x) -> bfs#1(@queue, @futurequeue, @x)
     , bfs#1(::(@t, @ts), @futurequeue, @x) ->
       bfs#3(@t, @futurequeue, @ts, @x)
     , bfs#1(nil(), @futurequeue, @x) -> bfs#2(@futurequeue, @x)
     , bfs#3(leaf(), @futurequeue, @ts, @x) ->
       bfs(@ts, @futurequeue, @x)
     , bfs#3(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
       bfs#4(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y)
     , bfs#2(::(@t, @ts), @x) -> bfs(reverse(::(@t, @ts)), nil(), @x)
     , bfs#2(nil(), @x) -> leaf()
     , reverse(@xs) -> appendreverse(@xs, nil())
     , bfs#4(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
       bfs(@ts, ::(@t2, ::(@t1, @futurequeue)), @x)
     , bfs#4(#true(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
       node(@y, @t1, @t2)
     , bfs2(@t, @x) -> bfs2#1(dobfs(@t, @x), @x)
     , dobfs(@t, @x) -> bfs(::(@t, nil()), nil(), @x)
     , bfs2#1(@t', @x) -> dobfs(@t', @x)
     , dfs(@queue, @x) -> dfs#1(@queue, @x)
     , dfs#1(::(@t, @ts), @x) -> dfs#2(@t, @t, @ts, @x)
     , dfs#1(nil(), @x) -> leaf()
     , dfs#2(leaf(), @t, @ts, @x) -> dfs(@ts, @x)
     , dfs#2(node(@a, @t1, @t2), @t, @ts, @x) ->
       dfs#3(#equal(@a, @x), @t, @t1, @t2, @ts, @x)
     , dfs#3(#false(), @t, @t1, @t2, @ts, @x) ->
       dfs(::(@t1, ::(@t2, @ts)), @x)
     , dfs#3(#true(), @t, @t1, @t2, @ts, @x) -> @t
     , dodfs(@t, @x) -> dfs(::(@t, nil()), @x)
     , #and(#false(), #false()) -> #false()
     , #and(#false(), #true()) -> #false()
     , #and(#true(), #false()) -> #false()
     , #and(#true(), #true()) -> #true() }
   Obligation:
     innermost runtime complexity
   Answer:
     YES(O(1),O(n^2))
   
   The following weak DPs constitute a sub-graph of the DG that is
   closed under successors. The DPs are removed.
   
   { dfs^#(@queue, @x) -> c_14(dfs#1^#(@queue, @x))
   , dfs#1^#(::(@t, @ts), @x) -> c_15(dfs#2^#(@t, @t, @ts, @x))
   , dfs#2^#(leaf(), @t, @ts, @x) -> c_16(dfs^#(@ts, @x))
   , dfs#2^#(node(@a, @t1, @t2), @t, @ts, @x) ->
     c_17(dfs#3^#(#equal(@a, @x), @t, @t1, @t2, @ts, @x))
   , dfs#3^#(#false(), @t, @t1, @t2, @ts, @x) ->
     c_18(dfs^#(::(@t1, ::(@t2, @ts)), @x)) }
   
   We are left with following problem, upon which TcT provides the
   certificate YES(O(1),O(n^2)).
   
   Strict DPs:
     { appendreverse^#(@toreverse, @sofar) ->
       c_1(appendreverse#1^#(@toreverse, @sofar))
     , appendreverse#1^#(::(@a, @as), @sofar) ->
       c_2(appendreverse^#(@as, ::(@a, @sofar)))
     , bfs^#(@queue, @futurequeue, @x) ->
       c_3(bfs#1^#(@queue, @futurequeue, @x))
     , bfs#1^#(::(@t, @ts), @futurequeue, @x) ->
       c_4(bfs#3^#(@t, @futurequeue, @ts, @x))
     , bfs#1^#(nil(), @futurequeue, @x) ->
       c_5(bfs#2^#(@futurequeue, @x))
     , bfs#3^#(leaf(), @futurequeue, @ts, @x) ->
       c_6(bfs^#(@ts, @futurequeue, @x))
     , bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
       c_7(bfs#4^#(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y))
     , bfs#2^#(::(@t, @ts), @x) ->
       c_8(bfs^#(reverse(::(@t, @ts)), nil(), @x), reverse^#(::(@t, @ts)))
     , bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
       c_9(bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x))
     , reverse^#(@xs) -> c_10(appendreverse^#(@xs, nil()))
     , bfs2^#(@t, @x) ->
       c_11(bfs2#1^#(dobfs(@t, @x), @x), dobfs^#(@t, @x))
     , bfs2#1^#(@t', @x) -> c_12(dobfs^#(@t', @x))
     , dobfs^#(@t, @x) -> c_13(bfs^#(::(@t, nil()), nil(), @x)) }
   Weak Trs:
     { #equal(@x, @y) -> #eq(@x, @y)
     , #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
       #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
     , #eq(::(@x_1, @x_2), nil()) -> #false()
     , #eq(::(@x_1, @x_2), leaf()) -> #false()
     , #eq(::(@x_1, @x_2), node(@y_1, @y_2, @y_3)) -> #false()
     , #eq(nil(), ::(@y_1, @y_2)) -> #false()
     , #eq(nil(), nil()) -> #true()
     , #eq(nil(), leaf()) -> #false()
     , #eq(nil(), node(@y_1, @y_2, @y_3)) -> #false()
     , #eq(leaf(), ::(@y_1, @y_2)) -> #false()
     , #eq(leaf(), nil()) -> #false()
     , #eq(leaf(), leaf()) -> #true()
     , #eq(leaf(), node(@y_1, @y_2, @y_3)) -> #false()
     , #eq(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2)) -> #false()
     , #eq(node(@x_1, @x_2, @x_3), nil()) -> #false()
     , #eq(node(@x_1, @x_2, @x_3), leaf()) -> #false()
     , #eq(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) ->
       #and(#eq(@x_1, @y_1), #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3)))
     , #eq(#0(), #0()) -> #true()
     , #eq(#0(), #neg(@y)) -> #false()
     , #eq(#0(), #pos(@y)) -> #false()
     , #eq(#0(), #s(@y)) -> #false()
     , #eq(#neg(@x), #0()) -> #false()
     , #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
     , #eq(#neg(@x), #pos(@y)) -> #false()
     , #eq(#pos(@x), #0()) -> #false()
     , #eq(#pos(@x), #neg(@y)) -> #false()
     , #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
     , #eq(#s(@x), #0()) -> #false()
     , #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
     , appendreverse(@toreverse, @sofar) ->
       appendreverse#1(@toreverse, @sofar)
     , appendreverse#1(::(@a, @as), @sofar) ->
       appendreverse(@as, ::(@a, @sofar))
     , appendreverse#1(nil(), @sofar) -> @sofar
     , bfs(@queue, @futurequeue, @x) -> bfs#1(@queue, @futurequeue, @x)
     , bfs#1(::(@t, @ts), @futurequeue, @x) ->
       bfs#3(@t, @futurequeue, @ts, @x)
     , bfs#1(nil(), @futurequeue, @x) -> bfs#2(@futurequeue, @x)
     , bfs#3(leaf(), @futurequeue, @ts, @x) ->
       bfs(@ts, @futurequeue, @x)
     , bfs#3(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
       bfs#4(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y)
     , bfs#2(::(@t, @ts), @x) -> bfs(reverse(::(@t, @ts)), nil(), @x)
     , bfs#2(nil(), @x) -> leaf()
     , reverse(@xs) -> appendreverse(@xs, nil())
     , bfs#4(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
       bfs(@ts, ::(@t2, ::(@t1, @futurequeue)), @x)
     , bfs#4(#true(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
       node(@y, @t1, @t2)
     , bfs2(@t, @x) -> bfs2#1(dobfs(@t, @x), @x)
     , dobfs(@t, @x) -> bfs(::(@t, nil()), nil(), @x)
     , bfs2#1(@t', @x) -> dobfs(@t', @x)
     , dfs(@queue, @x) -> dfs#1(@queue, @x)
     , dfs#1(::(@t, @ts), @x) -> dfs#2(@t, @t, @ts, @x)
     , dfs#1(nil(), @x) -> leaf()
     , dfs#2(leaf(), @t, @ts, @x) -> dfs(@ts, @x)
     , dfs#2(node(@a, @t1, @t2), @t, @ts, @x) ->
       dfs#3(#equal(@a, @x), @t, @t1, @t2, @ts, @x)
     , dfs#3(#false(), @t, @t1, @t2, @ts, @x) ->
       dfs(::(@t1, ::(@t2, @ts)), @x)
     , dfs#3(#true(), @t, @t1, @t2, @ts, @x) -> @t
     , dodfs(@t, @x) -> dfs(::(@t, nil()), @x)
     , #and(#false(), #false()) -> #false()
     , #and(#false(), #true()) -> #false()
     , #and(#true(), #false()) -> #false()
     , #and(#true(), #true()) -> #true() }
   Obligation:
     innermost runtime complexity
   Answer:
     YES(O(1),O(n^2))
   
   We replace rewrite rules by usable rules:
   
     Weak Usable Rules:
       { #equal(@x, @y) -> #eq(@x, @y)
       , #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
         #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
       , #eq(::(@x_1, @x_2), nil()) -> #false()
       , #eq(::(@x_1, @x_2), leaf()) -> #false()
       , #eq(::(@x_1, @x_2), node(@y_1, @y_2, @y_3)) -> #false()
       , #eq(nil(), ::(@y_1, @y_2)) -> #false()
       , #eq(nil(), nil()) -> #true()
       , #eq(nil(), leaf()) -> #false()
       , #eq(nil(), node(@y_1, @y_2, @y_3)) -> #false()
       , #eq(leaf(), ::(@y_1, @y_2)) -> #false()
       , #eq(leaf(), nil()) -> #false()
       , #eq(leaf(), leaf()) -> #true()
       , #eq(leaf(), node(@y_1, @y_2, @y_3)) -> #false()
       , #eq(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2)) -> #false()
       , #eq(node(@x_1, @x_2, @x_3), nil()) -> #false()
       , #eq(node(@x_1, @x_2, @x_3), leaf()) -> #false()
       , #eq(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) ->
         #and(#eq(@x_1, @y_1), #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3)))
       , #eq(#0(), #0()) -> #true()
       , #eq(#0(), #neg(@y)) -> #false()
       , #eq(#0(), #pos(@y)) -> #false()
       , #eq(#0(), #s(@y)) -> #false()
       , #eq(#neg(@x), #0()) -> #false()
       , #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
       , #eq(#neg(@x), #pos(@y)) -> #false()
       , #eq(#pos(@x), #0()) -> #false()
       , #eq(#pos(@x), #neg(@y)) -> #false()
       , #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
       , #eq(#s(@x), #0()) -> #false()
       , #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
       , appendreverse(@toreverse, @sofar) ->
         appendreverse#1(@toreverse, @sofar)
       , appendreverse#1(::(@a, @as), @sofar) ->
         appendreverse(@as, ::(@a, @sofar))
       , appendreverse#1(nil(), @sofar) -> @sofar
       , bfs(@queue, @futurequeue, @x) -> bfs#1(@queue, @futurequeue, @x)
       , bfs#1(::(@t, @ts), @futurequeue, @x) ->
         bfs#3(@t, @futurequeue, @ts, @x)
       , bfs#1(nil(), @futurequeue, @x) -> bfs#2(@futurequeue, @x)
       , bfs#3(leaf(), @futurequeue, @ts, @x) ->
         bfs(@ts, @futurequeue, @x)
       , bfs#3(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
         bfs#4(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y)
       , bfs#2(::(@t, @ts), @x) -> bfs(reverse(::(@t, @ts)), nil(), @x)
       , bfs#2(nil(), @x) -> leaf()
       , reverse(@xs) -> appendreverse(@xs, nil())
       , bfs#4(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
         bfs(@ts, ::(@t2, ::(@t1, @futurequeue)), @x)
       , bfs#4(#true(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
         node(@y, @t1, @t2)
       , dobfs(@t, @x) -> bfs(::(@t, nil()), nil(), @x)
       , #and(#false(), #false()) -> #false()
       , #and(#false(), #true()) -> #false()
       , #and(#true(), #false()) -> #false()
       , #and(#true(), #true()) -> #true() }
   
   We are left with following problem, upon which TcT provides the
   certificate YES(O(1),O(n^2)).
   
   Strict DPs:
     { appendreverse^#(@toreverse, @sofar) ->
       c_1(appendreverse#1^#(@toreverse, @sofar))
     , appendreverse#1^#(::(@a, @as), @sofar) ->
       c_2(appendreverse^#(@as, ::(@a, @sofar)))
     , bfs^#(@queue, @futurequeue, @x) ->
       c_3(bfs#1^#(@queue, @futurequeue, @x))
     , bfs#1^#(::(@t, @ts), @futurequeue, @x) ->
       c_4(bfs#3^#(@t, @futurequeue, @ts, @x))
     , bfs#1^#(nil(), @futurequeue, @x) ->
       c_5(bfs#2^#(@futurequeue, @x))
     , bfs#3^#(leaf(), @futurequeue, @ts, @x) ->
       c_6(bfs^#(@ts, @futurequeue, @x))
     , bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
       c_7(bfs#4^#(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y))
     , bfs#2^#(::(@t, @ts), @x) ->
       c_8(bfs^#(reverse(::(@t, @ts)), nil(), @x), reverse^#(::(@t, @ts)))
     , bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
       c_9(bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x))
     , reverse^#(@xs) -> c_10(appendreverse^#(@xs, nil()))
     , bfs2^#(@t, @x) ->
       c_11(bfs2#1^#(dobfs(@t, @x), @x), dobfs^#(@t, @x))
     , bfs2#1^#(@t', @x) -> c_12(dobfs^#(@t', @x))
     , dobfs^#(@t, @x) -> c_13(bfs^#(::(@t, nil()), nil(), @x)) }
   Weak Trs:
     { #equal(@x, @y) -> #eq(@x, @y)
     , #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
       #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
     , #eq(::(@x_1, @x_2), nil()) -> #false()
     , #eq(::(@x_1, @x_2), leaf()) -> #false()
     , #eq(::(@x_1, @x_2), node(@y_1, @y_2, @y_3)) -> #false()
     , #eq(nil(), ::(@y_1, @y_2)) -> #false()
     , #eq(nil(), nil()) -> #true()
     , #eq(nil(), leaf()) -> #false()
     , #eq(nil(), node(@y_1, @y_2, @y_3)) -> #false()
     , #eq(leaf(), ::(@y_1, @y_2)) -> #false()
     , #eq(leaf(), nil()) -> #false()
     , #eq(leaf(), leaf()) -> #true()
     , #eq(leaf(), node(@y_1, @y_2, @y_3)) -> #false()
     , #eq(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2)) -> #false()
     , #eq(node(@x_1, @x_2, @x_3), nil()) -> #false()
     , #eq(node(@x_1, @x_2, @x_3), leaf()) -> #false()
     , #eq(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) ->
       #and(#eq(@x_1, @y_1), #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3)))
     , #eq(#0(), #0()) -> #true()
     , #eq(#0(), #neg(@y)) -> #false()
     , #eq(#0(), #pos(@y)) -> #false()
     , #eq(#0(), #s(@y)) -> #false()
     , #eq(#neg(@x), #0()) -> #false()
     , #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
     , #eq(#neg(@x), #pos(@y)) -> #false()
     , #eq(#pos(@x), #0()) -> #false()
     , #eq(#pos(@x), #neg(@y)) -> #false()
     , #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
     , #eq(#s(@x), #0()) -> #false()
     , #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
     , appendreverse(@toreverse, @sofar) ->
       appendreverse#1(@toreverse, @sofar)
     , appendreverse#1(::(@a, @as), @sofar) ->
       appendreverse(@as, ::(@a, @sofar))
     , appendreverse#1(nil(), @sofar) -> @sofar
     , bfs(@queue, @futurequeue, @x) -> bfs#1(@queue, @futurequeue, @x)
     , bfs#1(::(@t, @ts), @futurequeue, @x) ->
       bfs#3(@t, @futurequeue, @ts, @x)
     , bfs#1(nil(), @futurequeue, @x) -> bfs#2(@futurequeue, @x)
     , bfs#3(leaf(), @futurequeue, @ts, @x) ->
       bfs(@ts, @futurequeue, @x)
     , bfs#3(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
       bfs#4(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y)
     , bfs#2(::(@t, @ts), @x) -> bfs(reverse(::(@t, @ts)), nil(), @x)
     , bfs#2(nil(), @x) -> leaf()
     , reverse(@xs) -> appendreverse(@xs, nil())
     , bfs#4(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
       bfs(@ts, ::(@t2, ::(@t1, @futurequeue)), @x)
     , bfs#4(#true(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
       node(@y, @t1, @t2)
     , dobfs(@t, @x) -> bfs(::(@t, nil()), nil(), @x)
     , #and(#false(), #false()) -> #false()
     , #and(#false(), #true()) -> #false()
     , #and(#true(), #false()) -> #false()
     , #and(#true(), #true()) -> #true() }
   Obligation:
     innermost runtime complexity
   Answer:
     YES(O(1),O(n^2))
   
   We decompose the input problem according to the dependency graph
   into the upper component
   
     { bfs^#(@queue, @futurequeue, @x) ->
       c_3(bfs#1^#(@queue, @futurequeue, @x))
     , bfs#1^#(::(@t, @ts), @futurequeue, @x) ->
       c_4(bfs#3^#(@t, @futurequeue, @ts, @x))
     , bfs#1^#(nil(), @futurequeue, @x) ->
       c_5(bfs#2^#(@futurequeue, @x))
     , bfs#3^#(leaf(), @futurequeue, @ts, @x) ->
       c_6(bfs^#(@ts, @futurequeue, @x))
     , bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
       c_7(bfs#4^#(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y))
     , bfs#2^#(::(@t, @ts), @x) ->
       c_8(bfs^#(reverse(::(@t, @ts)), nil(), @x), reverse^#(::(@t, @ts)))
     , bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
       c_9(bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x))
     , bfs2^#(@t, @x) ->
       c_11(bfs2#1^#(dobfs(@t, @x), @x), dobfs^#(@t, @x))
     , bfs2#1^#(@t', @x) -> c_12(dobfs^#(@t', @x))
     , dobfs^#(@t, @x) -> c_13(bfs^#(::(@t, nil()), nil(), @x)) }
   
   and lower component
   
     { appendreverse^#(@toreverse, @sofar) ->
       c_1(appendreverse#1^#(@toreverse, @sofar))
     , appendreverse#1^#(::(@a, @as), @sofar) ->
       c_2(appendreverse^#(@as, ::(@a, @sofar)))
     , reverse^#(@xs) -> c_10(appendreverse^#(@xs, nil())) }
   
   Further, following extension rules are added to the lower
   component.
   
   { bfs^#(@queue, @futurequeue, @x) ->
     bfs#1^#(@queue, @futurequeue, @x)
   , bfs#1^#(::(@t, @ts), @futurequeue, @x) ->
     bfs#3^#(@t, @futurequeue, @ts, @x)
   , bfs#1^#(nil(), @futurequeue, @x) -> bfs#2^#(@futurequeue, @x)
   , bfs#3^#(leaf(), @futurequeue, @ts, @x) ->
     bfs^#(@ts, @futurequeue, @x)
   , bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
     bfs#4^#(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y)
   , bfs#2^#(::(@t, @ts), @x) ->
     bfs^#(reverse(::(@t, @ts)), nil(), @x)
   , bfs#2^#(::(@t, @ts), @x) -> reverse^#(::(@t, @ts))
   , bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
     bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x)
   , bfs2^#(@t, @x) -> bfs2#1^#(dobfs(@t, @x), @x)
   , bfs2^#(@t, @x) -> dobfs^#(@t, @x)
   , bfs2#1^#(@t', @x) -> dobfs^#(@t', @x)
   , dobfs^#(@t, @x) -> bfs^#(::(@t, nil()), nil(), @x) }
   
   TcT solves the upper component with certificate YES(O(1),O(n^1)).
   
   Sub-proof:
   ----------
     We are left with following problem, upon which TcT provides the
     certificate YES(O(1),O(n^1)).
     
     Strict DPs:
       { bfs^#(@queue, @futurequeue, @x) ->
         c_3(bfs#1^#(@queue, @futurequeue, @x))
       , bfs#1^#(::(@t, @ts), @futurequeue, @x) ->
         c_4(bfs#3^#(@t, @futurequeue, @ts, @x))
       , bfs#1^#(nil(), @futurequeue, @x) ->
         c_5(bfs#2^#(@futurequeue, @x))
       , bfs#3^#(leaf(), @futurequeue, @ts, @x) ->
         c_6(bfs^#(@ts, @futurequeue, @x))
       , bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
         c_7(bfs#4^#(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y))
       , bfs#2^#(::(@t, @ts), @x) ->
         c_8(bfs^#(reverse(::(@t, @ts)), nil(), @x), reverse^#(::(@t, @ts)))
       , bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
         c_9(bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x))
       , bfs2^#(@t, @x) ->
         c_11(bfs2#1^#(dobfs(@t, @x), @x), dobfs^#(@t, @x))
       , bfs2#1^#(@t', @x) -> c_12(dobfs^#(@t', @x))
       , dobfs^#(@t, @x) -> c_13(bfs^#(::(@t, nil()), nil(), @x)) }
     Weak Trs:
       { #equal(@x, @y) -> #eq(@x, @y)
       , #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
         #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
       , #eq(::(@x_1, @x_2), nil()) -> #false()
       , #eq(::(@x_1, @x_2), leaf()) -> #false()
       , #eq(::(@x_1, @x_2), node(@y_1, @y_2, @y_3)) -> #false()
       , #eq(nil(), ::(@y_1, @y_2)) -> #false()
       , #eq(nil(), nil()) -> #true()
       , #eq(nil(), leaf()) -> #false()
       , #eq(nil(), node(@y_1, @y_2, @y_3)) -> #false()
       , #eq(leaf(), ::(@y_1, @y_2)) -> #false()
       , #eq(leaf(), nil()) -> #false()
       , #eq(leaf(), leaf()) -> #true()
       , #eq(leaf(), node(@y_1, @y_2, @y_3)) -> #false()
       , #eq(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2)) -> #false()
       , #eq(node(@x_1, @x_2, @x_3), nil()) -> #false()
       , #eq(node(@x_1, @x_2, @x_3), leaf()) -> #false()
       , #eq(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) ->
         #and(#eq(@x_1, @y_1), #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3)))
       , #eq(#0(), #0()) -> #true()
       , #eq(#0(), #neg(@y)) -> #false()
       , #eq(#0(), #pos(@y)) -> #false()
       , #eq(#0(), #s(@y)) -> #false()
       , #eq(#neg(@x), #0()) -> #false()
       , #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
       , #eq(#neg(@x), #pos(@y)) -> #false()
       , #eq(#pos(@x), #0()) -> #false()
       , #eq(#pos(@x), #neg(@y)) -> #false()
       , #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
       , #eq(#s(@x), #0()) -> #false()
       , #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
       , appendreverse(@toreverse, @sofar) ->
         appendreverse#1(@toreverse, @sofar)
       , appendreverse#1(::(@a, @as), @sofar) ->
         appendreverse(@as, ::(@a, @sofar))
       , appendreverse#1(nil(), @sofar) -> @sofar
       , bfs(@queue, @futurequeue, @x) -> bfs#1(@queue, @futurequeue, @x)
       , bfs#1(::(@t, @ts), @futurequeue, @x) ->
         bfs#3(@t, @futurequeue, @ts, @x)
       , bfs#1(nil(), @futurequeue, @x) -> bfs#2(@futurequeue, @x)
       , bfs#3(leaf(), @futurequeue, @ts, @x) ->
         bfs(@ts, @futurequeue, @x)
       , bfs#3(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
         bfs#4(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y)
       , bfs#2(::(@t, @ts), @x) -> bfs(reverse(::(@t, @ts)), nil(), @x)
       , bfs#2(nil(), @x) -> leaf()
       , reverse(@xs) -> appendreverse(@xs, nil())
       , bfs#4(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
         bfs(@ts, ::(@t2, ::(@t1, @futurequeue)), @x)
       , bfs#4(#true(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
         node(@y, @t1, @t2)
       , dobfs(@t, @x) -> bfs(::(@t, nil()), nil(), @x)
       , #and(#false(), #false()) -> #false()
       , #and(#false(), #true()) -> #false()
       , #and(#true(), #false()) -> #false()
       , #and(#true(), #true()) -> #true() }
     Obligation:
       innermost runtime complexity
     Answer:
       YES(O(1),O(n^1))
     
     Due to missing edges in the dependency-graph, the right-hand sides
     of following rules could be simplified:
     
       { bfs#2^#(::(@t, @ts), @x) ->
         c_8(bfs^#(reverse(::(@t, @ts)), nil(), @x),
             reverse^#(::(@t, @ts))) }
     
     We are left with following problem, upon which TcT provides the
     certificate YES(O(1),O(n^1)).
     
     Strict DPs:
       { bfs^#(@queue, @futurequeue, @x) ->
         c_1(bfs#1^#(@queue, @futurequeue, @x))
       , bfs#1^#(::(@t, @ts), @futurequeue, @x) ->
         c_2(bfs#3^#(@t, @futurequeue, @ts, @x))
       , bfs#1^#(nil(), @futurequeue, @x) ->
         c_3(bfs#2^#(@futurequeue, @x))
       , bfs#3^#(leaf(), @futurequeue, @ts, @x) ->
         c_4(bfs^#(@ts, @futurequeue, @x))
       , bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
         c_5(bfs#4^#(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y))
       , bfs#2^#(::(@t, @ts), @x) ->
         c_6(bfs^#(reverse(::(@t, @ts)), nil(), @x))
       , bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
         c_7(bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x))
       , bfs2^#(@t, @x) ->
         c_8(bfs2#1^#(dobfs(@t, @x), @x), dobfs^#(@t, @x))
       , bfs2#1^#(@t', @x) -> c_9(dobfs^#(@t', @x))
       , dobfs^#(@t, @x) -> c_10(bfs^#(::(@t, nil()), nil(), @x)) }
     Weak Trs:
       { #equal(@x, @y) -> #eq(@x, @y)
       , #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
         #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
       , #eq(::(@x_1, @x_2), nil()) -> #false()
       , #eq(::(@x_1, @x_2), leaf()) -> #false()
       , #eq(::(@x_1, @x_2), node(@y_1, @y_2, @y_3)) -> #false()
       , #eq(nil(), ::(@y_1, @y_2)) -> #false()
       , #eq(nil(), nil()) -> #true()
       , #eq(nil(), leaf()) -> #false()
       , #eq(nil(), node(@y_1, @y_2, @y_3)) -> #false()
       , #eq(leaf(), ::(@y_1, @y_2)) -> #false()
       , #eq(leaf(), nil()) -> #false()
       , #eq(leaf(), leaf()) -> #true()
       , #eq(leaf(), node(@y_1, @y_2, @y_3)) -> #false()
       , #eq(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2)) -> #false()
       , #eq(node(@x_1, @x_2, @x_3), nil()) -> #false()
       , #eq(node(@x_1, @x_2, @x_3), leaf()) -> #false()
       , #eq(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) ->
         #and(#eq(@x_1, @y_1), #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3)))
       , #eq(#0(), #0()) -> #true()
       , #eq(#0(), #neg(@y)) -> #false()
       , #eq(#0(), #pos(@y)) -> #false()
       , #eq(#0(), #s(@y)) -> #false()
       , #eq(#neg(@x), #0()) -> #false()
       , #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
       , #eq(#neg(@x), #pos(@y)) -> #false()
       , #eq(#pos(@x), #0()) -> #false()
       , #eq(#pos(@x), #neg(@y)) -> #false()
       , #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
       , #eq(#s(@x), #0()) -> #false()
       , #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
       , appendreverse(@toreverse, @sofar) ->
         appendreverse#1(@toreverse, @sofar)
       , appendreverse#1(::(@a, @as), @sofar) ->
         appendreverse(@as, ::(@a, @sofar))
       , appendreverse#1(nil(), @sofar) -> @sofar
       , bfs(@queue, @futurequeue, @x) -> bfs#1(@queue, @futurequeue, @x)
       , bfs#1(::(@t, @ts), @futurequeue, @x) ->
         bfs#3(@t, @futurequeue, @ts, @x)
       , bfs#1(nil(), @futurequeue, @x) -> bfs#2(@futurequeue, @x)
       , bfs#3(leaf(), @futurequeue, @ts, @x) ->
         bfs(@ts, @futurequeue, @x)
       , bfs#3(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
         bfs#4(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y)
       , bfs#2(::(@t, @ts), @x) -> bfs(reverse(::(@t, @ts)), nil(), @x)
       , bfs#2(nil(), @x) -> leaf()
       , reverse(@xs) -> appendreverse(@xs, nil())
       , bfs#4(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
         bfs(@ts, ::(@t2, ::(@t1, @futurequeue)), @x)
       , bfs#4(#true(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
         node(@y, @t1, @t2)
       , dobfs(@t, @x) -> bfs(::(@t, nil()), nil(), @x)
       , #and(#false(), #false()) -> #false()
       , #and(#false(), #true()) -> #false()
       , #and(#true(), #false()) -> #false()
       , #and(#true(), #true()) -> #true() }
     Obligation:
       innermost runtime complexity
     Answer:
       YES(O(1),O(n^1))
     
     We use the processor 'matrix interpretation of dimension 1' to
     orient following rules strictly.
     
     DPs:
       { 5: bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
            c_5(bfs#4^#(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y)) }
     Trs:
       { bfs#4(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
         bfs(@ts, ::(@t2, ::(@t1, @futurequeue)), @x) }
     
     Sub-proof:
     ----------
       The following argument positions are usable:
         Uargs(c_1) = {1}, Uargs(c_2) = {1}, Uargs(c_3) = {1},
         Uargs(c_4) = {1}, Uargs(c_5) = {1}, Uargs(c_6) = {1},
         Uargs(c_7) = {1}, Uargs(c_8) = {1, 2}, Uargs(c_9) = {1},
         Uargs(c_10) = {1}
       
       TcT has computed following constructor-based matrix interpretation
       satisfying not(EDA).
       
                              [#equal](x1, x2) = [0]
                                                    
                                 [#eq](x1, x2) = [0]
                                                    
                       [appendreverse](x1, x2) = [1] x1 + [1] x2 + [0]
                                                                      
                     [appendreverse#1](x1, x2) = [1] x1 + [1] x2 + [0]
                                                                      
                                  [::](x1, x2) = [1] x1 + [1] x2 + [0]
                                                                      
                                         [nil] = [0]
                                                    
                             [bfs](x1, x2, x3) = [1] x1 + [1] x2 + [0]
                                                                      
                           [bfs#1](x1, x2, x3) = [1] x1 + [1] x2 + [0]
                                                                      
                       [bfs#3](x1, x2, x3, x4) = [1] x1 + [1] x2 + [1] x3 + [0]
                                                                               
                               [bfs#2](x1, x2) = [1] x1 + [0]
                                                             
                                 [reverse](x1) = [1] x1 + [0]
                                                             
                                        [leaf] = [0]
                                                    
                            [node](x1, x2, x3) = [1] x2 + [1] x3 + [1]
                                                                      
           [bfs#4](x1, x2, x3, x4, x5, x6, x7) = [1] x2 + [1] x3 + [1] x4 + [1] x5 + [1]
                                                                                        
                                      [#false] = [0]
                                                    
                                       [#true] = [0]
                                                    
                               [dobfs](x1, x2) = [1] x1 + [0]
                                                             
                                [#and](x1, x2) = [0]
                                                    
                                          [#0] = [2]
                                                    
                                    [#neg](x1) = [1] x1 + [2]
                                                             
                                    [#pos](x1) = [1] x1 + [2]
                                                             
                                      [#s](x1) = [1] x1 + [2]
                                                             
                            [#equal^#](x1, x2) = [0]
                                                    
                               [#eq^#](x1, x2) = [0]
                                                    
                     [appendreverse^#](x1, x2) = [0]
                                                    
                   [appendreverse#1^#](x1, x2) = [0]
                                                    
                           [bfs^#](x1, x2, x3) = [1] x1 + [1] x2 + [1]
                                                                      
                         [bfs#1^#](x1, x2, x3) = [1] x1 + [1] x2 + [1]
                                                                      
                     [bfs#3^#](x1, x2, x3, x4) = [1] x1 + [1] x2 + [1] x3 + [1]
                                                                               
                             [bfs#2^#](x1, x2) = [1] x1 + [1]
                                                             
         [bfs#4^#](x1, x2, x3, x4, x5, x6, x7) = [1] x2 + [1] x3 + [1] x4 + [1] x5 + [1]
                                                                                        
                               [reverse^#](x1) = [0]
                                                    
                              [bfs2^#](x1, x2) = [2] x1 + [2] x2 + [2]
                                                                      
                            [bfs2#1^#](x1, x2) = [1] x1 + [1] x2 + [1]
                                                                      
                             [dobfs^#](x1, x2) = [1] x1 + [1]
                                                             
                               [dfs^#](x1, x2) = [0]
                                                    
                             [dfs#1^#](x1, x2) = [0]
                                                    
                     [dfs#2^#](x1, x2, x3, x4) = [0]
                                                    
             [dfs#3^#](x1, x2, x3, x4, x5, x6) = [0]
                                                    
                             [dodfs^#](x1, x2) = [0]
                                                    
                              [#and^#](x1, x2) = [0]
                                                    
                                     [c_3](x1) = [0]
                                                    
                                     [c_4](x1) = [0]
                                                    
                                     [c_5](x1) = [0]
                                                    
                                     [c_6](x1) = [0]
                                                    
                                     [c_7](x1) = [0]
                                                    
                                 [c_8](x1, x2) = [0]
                                                    
                                     [c_9](x1) = [0]
                                                    
                                [c_11](x1, x2) = [0]
                                                    
                                    [c_12](x1) = [0]
                                                    
                                    [c_13](x1) = [0]
                                                    
                                           [c] = [0]
                                                    
                                     [c_1](x1) = [1] x1 + [0]
                                                             
                                     [c_2](x1) = [1] x1 + [0]
                                                             
                                     [c_3](x1) = [1] x1 + [0]
                                                             
                                     [c_4](x1) = [1] x1 + [0]
                                                             
                                     [c_5](x1) = [1] x1 + [0]
                                                             
                                     [c_6](x1) = [1] x1 + [0]
                                                             
                                     [c_7](x1) = [1] x1 + [0]
                                                             
                                 [c_8](x1, x2) = [1] x1 + [1] x2 + [0]
                                                                      
                                     [c_9](x1) = [1] x1 + [0]
                                                             
                                    [c_10](x1) = [1] x1 + [0]
       
       This order satisfies following ordering constraints
       
                              [appendreverse(@toreverse, @sofar)] =  [1] @sofar + [1] @toreverse + [0]                                  
                                                                  >= [1] @sofar + [1] @toreverse + [0]                                  
                                                                  =  [appendreverse#1(@toreverse, @sofar)]                              
                                                                                                                                        
                           [appendreverse#1(::(@a, @as), @sofar)] =  [1] @a + [1] @as + [1] @sofar + [0]                                
                                                                  >= [1] @a + [1] @as + [1] @sofar + [0]                                
                                                                  =  [appendreverse(@as, ::(@a, @sofar))]                               
                                                                                                                                        
                                 [appendreverse#1(nil(), @sofar)] =  [1] @sofar + [0]                                                   
                                                                  >= [1] @sofar + [0]                                                   
                                                                  =  [@sofar]                                                           
                                                                                                                                        
                                  [bfs(@queue, @futurequeue, @x)] =  [1] @futurequeue + [1] @queue + [0]                                
                                                                  >= [1] @futurequeue + [1] @queue + [0]                                
                                                                  =  [bfs#1(@queue, @futurequeue, @x)]                                  
                                                                                                                                        
                           [bfs#1(::(@t, @ts), @futurequeue, @x)] =  [1] @futurequeue + [1] @t + [1] @ts + [0]                          
                                                                  >= [1] @futurequeue + [1] @t + [1] @ts + [0]                          
                                                                  =  [bfs#3(@t, @futurequeue, @ts, @x)]                                 
                                                                                                                                        
                                 [bfs#1(nil(), @futurequeue, @x)] =  [1] @futurequeue + [0]                                             
                                                                  >= [1] @futurequeue + [0]                                             
                                                                  =  [bfs#2(@futurequeue, @x)]                                          
                                                                                                                                        
                           [bfs#3(leaf(), @futurequeue, @ts, @x)] =  [1] @futurequeue + [1] @ts + [0]                                   
                                                                  >= [1] @futurequeue + [1] @ts + [0]                                   
                                                                  =  [bfs(@ts, @futurequeue, @x)]                                       
                                                                                                                                        
               [bfs#3(node(@y, @t1, @t2), @futurequeue, @ts, @x)] =  [1] @futurequeue + [1] @t1 + [1] @t2 + [1] @ts + [1]               
                                                                  >= [1] @futurequeue + [1] @t1 + [1] @t2 + [1] @ts + [1]               
                                                                  =  [bfs#4(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y)]       
                                                                                                                                        
                                         [bfs#2(::(@t, @ts), @x)] =  [1] @t + [1] @ts + [0]                                             
                                                                  >= [1] @t + [1] @ts + [0]                                             
                                                                  =  [bfs(reverse(::(@t, @ts)), nil(), @x)]                             
                                                                                                                                        
                                               [bfs#2(nil(), @x)] =  [0]                                                                
                                                                  >= [0]                                                                
                                                                  =  [leaf()]                                                           
                                                                                                                                        
                                                   [reverse(@xs)] =  [1] @xs + [0]                                                      
                                                                  >= [1] @xs + [0]                                                      
                                                                  =  [appendreverse(@xs, nil())]                                        
                                                                                                                                        
           [bfs#4(#false(), @futurequeue, @t1, @t2, @ts, @x, @y)] =  [1] @futurequeue + [1] @t1 + [1] @t2 + [1] @ts + [1]               
                                                                  >  [1] @futurequeue + [1] @t1 + [1] @t2 + [1] @ts + [0]               
                                                                  =  [bfs(@ts, ::(@t2, ::(@t1, @futurequeue)), @x)]                     
                                                                                                                                        
            [bfs#4(#true(), @futurequeue, @t1, @t2, @ts, @x, @y)] =  [1] @futurequeue + [1] @t1 + [1] @t2 + [1] @ts + [1]               
                                                                  >= [1] @t1 + [1] @t2 + [1]                                            
                                                                  =  [node(@y, @t1, @t2)]                                               
                                                                                                                                        
                                                  [dobfs(@t, @x)] =  [1] @t + [0]                                                       
                                                                  >= [1] @t + [0]                                                       
                                                                  =  [bfs(::(@t, nil()), nil(), @x)]                                    
                                                                                                                                        
                                [bfs^#(@queue, @futurequeue, @x)] =  [1] @futurequeue + [1] @queue + [1]                                
                                                                  >= [1] @futurequeue + [1] @queue + [1]                                
                                                                  =  [c_1(bfs#1^#(@queue, @futurequeue, @x))]                           
                                                                                                                                        
                         [bfs#1^#(::(@t, @ts), @futurequeue, @x)] =  [1] @futurequeue + [1] @t + [1] @ts + [1]                          
                                                                  >= [1] @futurequeue + [1] @t + [1] @ts + [1]                          
                                                                  =  [c_2(bfs#3^#(@t, @futurequeue, @ts, @x))]                          
                                                                                                                                        
                               [bfs#1^#(nil(), @futurequeue, @x)] =  [1] @futurequeue + [1]                                             
                                                                  >= [1] @futurequeue + [1]                                             
                                                                  =  [c_3(bfs#2^#(@futurequeue, @x))]                                   
                                                                                                                                        
                         [bfs#3^#(leaf(), @futurequeue, @ts, @x)] =  [1] @futurequeue + [1] @ts + [1]                                   
                                                                  >= [1] @futurequeue + [1] @ts + [1]                                   
                                                                  =  [c_4(bfs^#(@ts, @futurequeue, @x))]                                
                                                                                                                                        
             [bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x)] =  [1] @futurequeue + [1] @t1 + [1] @t2 + [1] @ts + [2]               
                                                                  >  [1] @futurequeue + [1] @t1 + [1] @t2 + [1] @ts + [1]               
                                                                  =  [c_5(bfs#4^#(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y))]
                                                                                                                                        
                                       [bfs#2^#(::(@t, @ts), @x)] =  [1] @t + [1] @ts + [1]                                             
                                                                  >= [1] @t + [1] @ts + [1]                                             
                                                                  =  [c_6(bfs^#(reverse(::(@t, @ts)), nil(), @x))]                      
                                                                                                                                        
         [bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y)] =  [1] @futurequeue + [1] @t1 + [1] @t2 + [1] @ts + [1]               
                                                                  >= [1] @futurequeue + [1] @t1 + [1] @t2 + [1] @ts + [1]               
                                                                  =  [c_7(bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x))]              
                                                                                                                                        
                                                 [bfs2^#(@t, @x)] =  [2] @t + [2] @x + [2]                                              
                                                                  >= [2] @t + [1] @x + [2]                                              
                                                                  =  [c_8(bfs2#1^#(dobfs(@t, @x), @x), dobfs^#(@t, @x))]                
                                                                                                                                        
                                              [bfs2#1^#(@t', @x)] =  [1] @t' + [1] @x + [1]                                             
                                                                  >= [1] @t' + [1]                                                      
                                                                  =  [c_9(dobfs^#(@t', @x))]                                            
                                                                                                                                        
                                                [dobfs^#(@t, @x)] =  [1] @t + [1]                                                       
                                                                  >= [1] @t + [1]                                                       
                                                                  =  [c_10(bfs^#(::(@t, nil()), nil(), @x))]                            
                                                                                                                                        
     
     Consider the set of all dependency pairs
     
     DPs:
       { 1: bfs^#(@queue, @futurequeue, @x) ->
            c_1(bfs#1^#(@queue, @futurequeue, @x))
       , 2: bfs#1^#(::(@t, @ts), @futurequeue, @x) ->
            c_2(bfs#3^#(@t, @futurequeue, @ts, @x))
       , 3: bfs#1^#(nil(), @futurequeue, @x) ->
            c_3(bfs#2^#(@futurequeue, @x))
       , 4: bfs#3^#(leaf(), @futurequeue, @ts, @x) ->
            c_4(bfs^#(@ts, @futurequeue, @x))
       , 5: bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
            c_5(bfs#4^#(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y))
       , 6: bfs#2^#(::(@t, @ts), @x) ->
            c_6(bfs^#(reverse(::(@t, @ts)), nil(), @x))
       , 7: bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
            c_7(bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x))
       , 8: bfs2^#(@t, @x) ->
            c_8(bfs2#1^#(dobfs(@t, @x), @x), dobfs^#(@t, @x))
       , 9: bfs2#1^#(@t', @x) -> c_9(dobfs^#(@t', @x))
       , 10: dobfs^#(@t, @x) -> c_10(bfs^#(::(@t, nil()), nil(), @x)) }
     
     Processor 'matrix interpretation of dimension 1' induces the
     complexity certificate YES(?,O(n^1)) on application of dependency
     pairs {5}. These cover all (indirect) predecessors of dependency
     pairs {5,7,8,9,10}, their number of application is equally bounded.
     The dependency pairs are shifted into the corresponding weak
     component(s).
     
     
     We are left with following problem, upon which TcT provides the
     certificate YES(O(1),O(n^1)).
     
     Strict DPs:
       { bfs^#(@queue, @futurequeue, @x) ->
         c_1(bfs#1^#(@queue, @futurequeue, @x))
       , bfs#1^#(::(@t, @ts), @futurequeue, @x) ->
         c_2(bfs#3^#(@t, @futurequeue, @ts, @x))
       , bfs#1^#(nil(), @futurequeue, @x) ->
         c_3(bfs#2^#(@futurequeue, @x))
       , bfs#3^#(leaf(), @futurequeue, @ts, @x) ->
         c_4(bfs^#(@ts, @futurequeue, @x))
       , bfs#2^#(::(@t, @ts), @x) ->
         c_6(bfs^#(reverse(::(@t, @ts)), nil(), @x)) }
     Weak DPs:
       { bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
         c_5(bfs#4^#(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y))
       , bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
         c_7(bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x))
       , bfs2^#(@t, @x) ->
         c_8(bfs2#1^#(dobfs(@t, @x), @x), dobfs^#(@t, @x))
       , bfs2#1^#(@t', @x) -> c_9(dobfs^#(@t', @x))
       , dobfs^#(@t, @x) -> c_10(bfs^#(::(@t, nil()), nil(), @x)) }
     Weak Trs:
       { #equal(@x, @y) -> #eq(@x, @y)
       , #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
         #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
       , #eq(::(@x_1, @x_2), nil()) -> #false()
       , #eq(::(@x_1, @x_2), leaf()) -> #false()
       , #eq(::(@x_1, @x_2), node(@y_1, @y_2, @y_3)) -> #false()
       , #eq(nil(), ::(@y_1, @y_2)) -> #false()
       , #eq(nil(), nil()) -> #true()
       , #eq(nil(), leaf()) -> #false()
       , #eq(nil(), node(@y_1, @y_2, @y_3)) -> #false()
       , #eq(leaf(), ::(@y_1, @y_2)) -> #false()
       , #eq(leaf(), nil()) -> #false()
       , #eq(leaf(), leaf()) -> #true()
       , #eq(leaf(), node(@y_1, @y_2, @y_3)) -> #false()
       , #eq(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2)) -> #false()
       , #eq(node(@x_1, @x_2, @x_3), nil()) -> #false()
       , #eq(node(@x_1, @x_2, @x_3), leaf()) -> #false()
       , #eq(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) ->
         #and(#eq(@x_1, @y_1), #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3)))
       , #eq(#0(), #0()) -> #true()
       , #eq(#0(), #neg(@y)) -> #false()
       , #eq(#0(), #pos(@y)) -> #false()
       , #eq(#0(), #s(@y)) -> #false()
       , #eq(#neg(@x), #0()) -> #false()
       , #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
       , #eq(#neg(@x), #pos(@y)) -> #false()
       , #eq(#pos(@x), #0()) -> #false()
       , #eq(#pos(@x), #neg(@y)) -> #false()
       , #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
       , #eq(#s(@x), #0()) -> #false()
       , #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
       , appendreverse(@toreverse, @sofar) ->
         appendreverse#1(@toreverse, @sofar)
       , appendreverse#1(::(@a, @as), @sofar) ->
         appendreverse(@as, ::(@a, @sofar))
       , appendreverse#1(nil(), @sofar) -> @sofar
       , bfs(@queue, @futurequeue, @x) -> bfs#1(@queue, @futurequeue, @x)
       , bfs#1(::(@t, @ts), @futurequeue, @x) ->
         bfs#3(@t, @futurequeue, @ts, @x)
       , bfs#1(nil(), @futurequeue, @x) -> bfs#2(@futurequeue, @x)
       , bfs#3(leaf(), @futurequeue, @ts, @x) ->
         bfs(@ts, @futurequeue, @x)
       , bfs#3(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
         bfs#4(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y)
       , bfs#2(::(@t, @ts), @x) -> bfs(reverse(::(@t, @ts)), nil(), @x)
       , bfs#2(nil(), @x) -> leaf()
       , reverse(@xs) -> appendreverse(@xs, nil())
       , bfs#4(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
         bfs(@ts, ::(@t2, ::(@t1, @futurequeue)), @x)
       , bfs#4(#true(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
         node(@y, @t1, @t2)
       , dobfs(@t, @x) -> bfs(::(@t, nil()), nil(), @x)
       , #and(#false(), #false()) -> #false()
       , #and(#false(), #true()) -> #false()
       , #and(#true(), #false()) -> #false()
       , #and(#true(), #true()) -> #true() }
     Obligation:
       innermost runtime complexity
     Answer:
       YES(O(1),O(n^1))
     
     We use the processor 'matrix interpretation of dimension 1' to
     orient following rules strictly.
     
     DPs:
       { 4: bfs#3^#(leaf(), @futurequeue, @ts, @x) ->
            c_4(bfs^#(@ts, @futurequeue, @x))
       , 7: bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
            c_7(bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x))
       , 8: bfs2^#(@t, @x) ->
            c_8(bfs2#1^#(dobfs(@t, @x), @x), dobfs^#(@t, @x)) }
     Trs:
       { bfs#1(::(@t, @ts), @futurequeue, @x) ->
         bfs#3(@t, @futurequeue, @ts, @x) }
     
     Sub-proof:
     ----------
       The following argument positions are usable:
         Uargs(c_1) = {1}, Uargs(c_2) = {1}, Uargs(c_3) = {1},
         Uargs(c_4) = {1}, Uargs(c_5) = {1}, Uargs(c_6) = {1},
         Uargs(c_7) = {1}, Uargs(c_8) = {1, 2}, Uargs(c_9) = {1},
         Uargs(c_10) = {1}
       
       TcT has computed following constructor-based matrix interpretation
       satisfying not(EDA).
       
                              [#equal](x1, x2) = [0]
                                                    
                                 [#eq](x1, x2) = [0]
                                                    
                       [appendreverse](x1, x2) = [1] x1 + [1] x2 + [0]
                                                                      
                     [appendreverse#1](x1, x2) = [1] x1 + [1] x2 + [0]
                                                                      
                                  [::](x1, x2) = [1] x1 + [1] x2 + [0]
                                                                      
                                         [nil] = [0]
                                                    
                             [bfs](x1, x2, x3) = [1] x1 + [1] x2 + [1]
                                                                      
                           [bfs#1](x1, x2, x3) = [1] x1 + [1] x2 + [1]
                                                                      
                       [bfs#3](x1, x2, x3, x4) = [1] x1 + [1] x2 + [1] x3 + [0]
                                                                               
                               [bfs#2](x1, x2) = [1] x1 + [1]
                                                             
                                 [reverse](x1) = [1] x1 + [0]
                                                             
                                        [leaf] = [1]
                                                    
                            [node](x1, x2, x3) = [1] x2 + [1] x3 + [1]
                                                                      
           [bfs#4](x1, x2, x3, x4, x5, x6, x7) = [1] x2 + [1] x3 + [1] x4 + [1] x5 + [1]
                                                                                        
                                      [#false] = [0]
                                                    
                                       [#true] = [0]
                                                    
                               [dobfs](x1, x2) = [1] x1 + [1]
                                                             
                                [#and](x1, x2) = [0]
                                                    
                                          [#0] = [0]
                                                    
                                    [#neg](x1) = [1] x1 + [0]
                                                             
                                    [#pos](x1) = [1] x1 + [0]
                                                             
                                      [#s](x1) = [1] x1 + [0]
                                                             
                            [#equal^#](x1, x2) = [0]
                                                    
                               [#eq^#](x1, x2) = [0]
                                                    
                     [appendreverse^#](x1, x2) = [0]
                                                    
                   [appendreverse#1^#](x1, x2) = [0]
                                                    
                           [bfs^#](x1, x2, x3) = [1] x1 + [1] x2 + [0]
                                                                      
                         [bfs#1^#](x1, x2, x3) = [1] x1 + [1] x2 + [0]
                                                                      
                     [bfs#3^#](x1, x2, x3, x4) = [1] x1 + [1] x2 + [1] x3 + [0]
                                                                               
                             [bfs#2^#](x1, x2) = [1] x1 + [0]
                                                             
         [bfs#4^#](x1, x2, x3, x4, x5, x6, x7) = [2] x1 + [1] x2 + [1] x3 + [1] x4 + [1] x5 + [1]
                                                                                                 
                               [reverse^#](x1) = [0]
                                                    
                              [bfs2^#](x1, x2) = [2] x1 + [2] x2 + [2]
                                                                      
                            [bfs2#1^#](x1, x2) = [1] x1 + [0]
                                                             
                             [dobfs^#](x1, x2) = [1] x1 + [0]
                                                             
                               [dfs^#](x1, x2) = [0]
                                                    
                             [dfs#1^#](x1, x2) = [0]
                                                    
                     [dfs#2^#](x1, x2, x3, x4) = [0]
                                                    
             [dfs#3^#](x1, x2, x3, x4, x5, x6) = [0]
                                                    
                             [dodfs^#](x1, x2) = [0]
                                                    
                              [#and^#](x1, x2) = [0]
                                                    
                                     [c_3](x1) = [0]
                                                    
                                     [c_4](x1) = [0]
                                                    
                                     [c_5](x1) = [0]
                                                    
                                     [c_6](x1) = [0]
                                                    
                                     [c_7](x1) = [0]
                                                    
                                 [c_8](x1, x2) = [0]
                                                    
                                     [c_9](x1) = [0]
                                                    
                                [c_11](x1, x2) = [0]
                                                    
                                    [c_12](x1) = [0]
                                                    
                                    [c_13](x1) = [0]
                                                    
                                           [c] = [0]
                                                    
                                     [c_1](x1) = [1] x1 + [0]
                                                             
                                     [c_2](x1) = [1] x1 + [0]
                                                             
                                     [c_3](x1) = [1] x1 + [0]
                                                             
                                     [c_4](x1) = [1] x1 + [0]
                                                             
                                     [c_5](x1) = [1] x1 + [0]
                                                             
                                     [c_6](x1) = [1] x1 + [0]
                                                             
                                     [c_7](x1) = [1] x1 + [0]
                                                             
                                 [c_8](x1, x2) = [1] x1 + [1] x2 + [0]
                                                                      
                                     [c_9](x1) = [1] x1 + [0]
                                                             
                                    [c_10](x1) = [1] x1 + [0]
       
       This order satisfies following ordering constraints
       
                                                 [#equal(@x, @y)] =  [0]                                                                
                                                                  >= [0]                                                                
                                                                  =  [#eq(@x, @y)]                                                      
                                                                                                                                        
                            [#eq(::(@x_1, @x_2), ::(@y_1, @y_2))] =  [0]                                                                
                                                                  >= [0]                                                                
                                                                  =  [#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))]                           
                                                                                                                                        
                                     [#eq(::(@x_1, @x_2), nil())] =  [0]                                                                
                                                                  >= [0]                                                                
                                                                  =  [#false()]                                                         
                                                                                                                                        
                                    [#eq(::(@x_1, @x_2), leaf())] =  [0]                                                                
                                                                  >= [0]                                                                
                                                                  =  [#false()]                                                         
                                                                                                                                        
                    [#eq(::(@x_1, @x_2), node(@y_1, @y_2, @y_3))] =  [0]                                                                
                                                                  >= [0]                                                                
                                                                  =  [#false()]                                                         
                                                                                                                                        
                                     [#eq(nil(), ::(@y_1, @y_2))] =  [0]                                                                
                                                                  >= [0]                                                                
                                                                  =  [#false()]                                                         
                                                                                                                                        
                                              [#eq(nil(), nil())] =  [0]                                                                
                                                                  >= [0]                                                                
                                                                  =  [#true()]                                                          
                                                                                                                                        
                                             [#eq(nil(), leaf())] =  [0]                                                                
                                                                  >= [0]                                                                
                                                                  =  [#false()]                                                         
                                                                                                                                        
                             [#eq(nil(), node(@y_1, @y_2, @y_3))] =  [0]                                                                
                                                                  >= [0]                                                                
                                                                  =  [#false()]                                                         
                                                                                                                                        
                                    [#eq(leaf(), ::(@y_1, @y_2))] =  [0]                                                                
                                                                  >= [0]                                                                
                                                                  =  [#false()]                                                         
                                                                                                                                        
                                             [#eq(leaf(), nil())] =  [0]                                                                
                                                                  >= [0]                                                                
                                                                  =  [#false()]                                                         
                                                                                                                                        
                                            [#eq(leaf(), leaf())] =  [0]                                                                
                                                                  >= [0]                                                                
                                                                  =  [#true()]                                                          
                                                                                                                                        
                            [#eq(leaf(), node(@y_1, @y_2, @y_3))] =  [0]                                                                
                                                                  >= [0]                                                                
                                                                  =  [#false()]                                                         
                                                                                                                                        
                    [#eq(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2))] =  [0]                                                                
                                                                  >= [0]                                                                
                                                                  =  [#false()]                                                         
                                                                                                                                        
                             [#eq(node(@x_1, @x_2, @x_3), nil())] =  [0]                                                                
                                                                  >= [0]                                                                
                                                                  =  [#false()]                                                         
                                                                                                                                        
                            [#eq(node(@x_1, @x_2, @x_3), leaf())] =  [0]                                                                
                                                                  >= [0]                                                                
                                                                  =  [#false()]                                                         
                                                                                                                                        
            [#eq(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3))] =  [0]                                                                
                                                                  >= [0]                                                                
                                                                  =  [#and(#eq(@x_1, @y_1), #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3)))]    
                                                                                                                                        
                                                [#eq(#0(), #0())] =  [0]                                                                
                                                                  >= [0]                                                                
                                                                  =  [#true()]                                                          
                                                                                                                                        
                                            [#eq(#0(), #neg(@y))] =  [0]                                                                
                                                                  >= [0]                                                                
                                                                  =  [#false()]                                                         
                                                                                                                                        
                                            [#eq(#0(), #pos(@y))] =  [0]                                                                
                                                                  >= [0]                                                                
                                                                  =  [#false()]                                                         
                                                                                                                                        
                                              [#eq(#0(), #s(@y))] =  [0]                                                                
                                                                  >= [0]                                                                
                                                                  =  [#false()]                                                         
                                                                                                                                        
                                            [#eq(#neg(@x), #0())] =  [0]                                                                
                                                                  >= [0]                                                                
                                                                  =  [#false()]                                                         
                                                                                                                                        
                                        [#eq(#neg(@x), #neg(@y))] =  [0]                                                                
                                                                  >= [0]                                                                
                                                                  =  [#eq(@x, @y)]                                                      
                                                                                                                                        
                                        [#eq(#neg(@x), #pos(@y))] =  [0]                                                                
                                                                  >= [0]                                                                
                                                                  =  [#false()]                                                         
                                                                                                                                        
                                            [#eq(#pos(@x), #0())] =  [0]                                                                
                                                                  >= [0]                                                                
                                                                  =  [#false()]                                                         
                                                                                                                                        
                                        [#eq(#pos(@x), #neg(@y))] =  [0]                                                                
                                                                  >= [0]                                                                
                                                                  =  [#false()]                                                         
                                                                                                                                        
                                        [#eq(#pos(@x), #pos(@y))] =  [0]                                                                
                                                                  >= [0]                                                                
                                                                  =  [#eq(@x, @y)]                                                      
                                                                                                                                        
                                              [#eq(#s(@x), #0())] =  [0]                                                                
                                                                  >= [0]                                                                
                                                                  =  [#false()]                                                         
                                                                                                                                        
                                            [#eq(#s(@x), #s(@y))] =  [0]                                                                
                                                                  >= [0]                                                                
                                                                  =  [#eq(@x, @y)]                                                      
                                                                                                                                        
                              [appendreverse(@toreverse, @sofar)] =  [1] @sofar + [1] @toreverse + [0]                                  
                                                                  >= [1] @sofar + [1] @toreverse + [0]                                  
                                                                  =  [appendreverse#1(@toreverse, @sofar)]                              
                                                                                                                                        
                           [appendreverse#1(::(@a, @as), @sofar)] =  [1] @a + [1] @as + [1] @sofar + [0]                                
                                                                  >= [1] @a + [1] @as + [1] @sofar + [0]                                
                                                                  =  [appendreverse(@as, ::(@a, @sofar))]                               
                                                                                                                                        
                                 [appendreverse#1(nil(), @sofar)] =  [1] @sofar + [0]                                                   
                                                                  >= [1] @sofar + [0]                                                   
                                                                  =  [@sofar]                                                           
                                                                                                                                        
                                  [bfs(@queue, @futurequeue, @x)] =  [1] @futurequeue + [1] @queue + [1]                                
                                                                  >= [1] @futurequeue + [1] @queue + [1]                                
                                                                  =  [bfs#1(@queue, @futurequeue, @x)]                                  
                                                                                                                                        
                           [bfs#1(::(@t, @ts), @futurequeue, @x)] =  [1] @futurequeue + [1] @t + [1] @ts + [1]                          
                                                                  >  [1] @futurequeue + [1] @t + [1] @ts + [0]                          
                                                                  =  [bfs#3(@t, @futurequeue, @ts, @x)]                                 
                                                                                                                                        
                                 [bfs#1(nil(), @futurequeue, @x)] =  [1] @futurequeue + [1]                                             
                                                                  >= [1] @futurequeue + [1]                                             
                                                                  =  [bfs#2(@futurequeue, @x)]                                          
                                                                                                                                        
                           [bfs#3(leaf(), @futurequeue, @ts, @x)] =  [1] @futurequeue + [1] @ts + [1]                                   
                                                                  >= [1] @futurequeue + [1] @ts + [1]                                   
                                                                  =  [bfs(@ts, @futurequeue, @x)]                                       
                                                                                                                                        
               [bfs#3(node(@y, @t1, @t2), @futurequeue, @ts, @x)] =  [1] @futurequeue + [1] @t1 + [1] @t2 + [1] @ts + [1]               
                                                                  >= [1] @futurequeue + [1] @t1 + [1] @t2 + [1] @ts + [1]               
                                                                  =  [bfs#4(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y)]       
                                                                                                                                        
                                         [bfs#2(::(@t, @ts), @x)] =  [1] @t + [1] @ts + [1]                                             
                                                                  >= [1] @t + [1] @ts + [1]                                             
                                                                  =  [bfs(reverse(::(@t, @ts)), nil(), @x)]                             
                                                                                                                                        
                                               [bfs#2(nil(), @x)] =  [1]                                                                
                                                                  >= [1]                                                                
                                                                  =  [leaf()]                                                           
                                                                                                                                        
                                                   [reverse(@xs)] =  [1] @xs + [0]                                                      
                                                                  >= [1] @xs + [0]                                                      
                                                                  =  [appendreverse(@xs, nil())]                                        
                                                                                                                                        
           [bfs#4(#false(), @futurequeue, @t1, @t2, @ts, @x, @y)] =  [1] @futurequeue + [1] @t1 + [1] @t2 + [1] @ts + [1]               
                                                                  >= [1] @futurequeue + [1] @t1 + [1] @t2 + [1] @ts + [1]               
                                                                  =  [bfs(@ts, ::(@t2, ::(@t1, @futurequeue)), @x)]                     
                                                                                                                                        
            [bfs#4(#true(), @futurequeue, @t1, @t2, @ts, @x, @y)] =  [1] @futurequeue + [1] @t1 + [1] @t2 + [1] @ts + [1]               
                                                                  >= [1] @t1 + [1] @t2 + [1]                                            
                                                                  =  [node(@y, @t1, @t2)]                                               
                                                                                                                                        
                                                  [dobfs(@t, @x)] =  [1] @t + [1]                                                       
                                                                  >= [1] @t + [1]                                                       
                                                                  =  [bfs(::(@t, nil()), nil(), @x)]                                    
                                                                                                                                        
                                       [#and(#false(), #false())] =  [0]                                                                
                                                                  >= [0]                                                                
                                                                  =  [#false()]                                                         
                                                                                                                                        
                                        [#and(#false(), #true())] =  [0]                                                                
                                                                  >= [0]                                                                
                                                                  =  [#false()]                                                         
                                                                                                                                        
                                        [#and(#true(), #false())] =  [0]                                                                
                                                                  >= [0]                                                                
                                                                  =  [#false()]                                                         
                                                                                                                                        
                                         [#and(#true(), #true())] =  [0]                                                                
                                                                  >= [0]                                                                
                                                                  =  [#true()]                                                          
                                                                                                                                        
                                [bfs^#(@queue, @futurequeue, @x)] =  [1] @futurequeue + [1] @queue + [0]                                
                                                                  >= [1] @futurequeue + [1] @queue + [0]                                
                                                                  =  [c_1(bfs#1^#(@queue, @futurequeue, @x))]                           
                                                                                                                                        
                         [bfs#1^#(::(@t, @ts), @futurequeue, @x)] =  [1] @futurequeue + [1] @t + [1] @ts + [0]                          
                                                                  >= [1] @futurequeue + [1] @t + [1] @ts + [0]                          
                                                                  =  [c_2(bfs#3^#(@t, @futurequeue, @ts, @x))]                          
                                                                                                                                        
                               [bfs#1^#(nil(), @futurequeue, @x)] =  [1] @futurequeue + [0]                                             
                                                                  >= [1] @futurequeue + [0]                                             
                                                                  =  [c_3(bfs#2^#(@futurequeue, @x))]                                   
                                                                                                                                        
                         [bfs#3^#(leaf(), @futurequeue, @ts, @x)] =  [1] @futurequeue + [1] @ts + [1]                                   
                                                                  >  [1] @futurequeue + [1] @ts + [0]                                   
                                                                  =  [c_4(bfs^#(@ts, @futurequeue, @x))]                                
                                                                                                                                        
             [bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x)] =  [1] @futurequeue + [1] @t1 + [1] @t2 + [1] @ts + [1]               
                                                                  >= [1] @futurequeue + [1] @t1 + [1] @t2 + [1] @ts + [1]               
                                                                  =  [c_5(bfs#4^#(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y))]
                                                                                                                                        
                                       [bfs#2^#(::(@t, @ts), @x)] =  [1] @t + [1] @ts + [0]                                             
                                                                  >= [1] @t + [1] @ts + [0]                                             
                                                                  =  [c_6(bfs^#(reverse(::(@t, @ts)), nil(), @x))]                      
                                                                                                                                        
         [bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y)] =  [1] @futurequeue + [1] @t1 + [1] @t2 + [1] @ts + [1]               
                                                                  >  [1] @futurequeue + [1] @t1 + [1] @t2 + [1] @ts + [0]               
                                                                  =  [c_7(bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x))]              
                                                                                                                                        
                                                 [bfs2^#(@t, @x)] =  [2] @t + [2] @x + [2]                                              
                                                                  >  [2] @t + [1]                                                       
                                                                  =  [c_8(bfs2#1^#(dobfs(@t, @x), @x), dobfs^#(@t, @x))]                
                                                                                                                                        
                                              [bfs2#1^#(@t', @x)] =  [1] @t' + [0]                                                      
                                                                  >= [1] @t' + [0]                                                      
                                                                  =  [c_9(dobfs^#(@t', @x))]                                            
                                                                                                                                        
                                                [dobfs^#(@t, @x)] =  [1] @t + [0]                                                       
                                                                  >= [1] @t + [0]                                                       
                                                                  =  [c_10(bfs^#(::(@t, nil()), nil(), @x))]                            
                                                                                                                                        
     
     Consider the set of all dependency pairs
     
     DPs:
       { 1: bfs^#(@queue, @futurequeue, @x) ->
            c_1(bfs#1^#(@queue, @futurequeue, @x))
       , 2: bfs#1^#(::(@t, @ts), @futurequeue, @x) ->
            c_2(bfs#3^#(@t, @futurequeue, @ts, @x))
       , 3: bfs#1^#(nil(), @futurequeue, @x) ->
            c_3(bfs#2^#(@futurequeue, @x))
       , 4: bfs#3^#(leaf(), @futurequeue, @ts, @x) ->
            c_4(bfs^#(@ts, @futurequeue, @x))
       , 5: bfs#2^#(::(@t, @ts), @x) ->
            c_6(bfs^#(reverse(::(@t, @ts)), nil(), @x))
       , 6: bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
            c_5(bfs#4^#(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y))
       , 7: bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
            c_7(bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x))
       , 8: bfs2^#(@t, @x) ->
            c_8(bfs2#1^#(dobfs(@t, @x), @x), dobfs^#(@t, @x))
       , 9: bfs2#1^#(@t', @x) -> c_9(dobfs^#(@t', @x))
       , 10: dobfs^#(@t, @x) -> c_10(bfs^#(::(@t, nil()), nil(), @x)) }
     
     Processor 'matrix interpretation of dimension 1' induces the
     complexity certificate YES(?,O(n^1)) on application of dependency
     pairs {4,7,8}. These cover all (indirect) predecessors of
     dependency pairs {4,7,8,9,10}, their number of application is
     equally bounded. The dependency pairs are shifted into the
     corresponding weak component(s).
     
     
     We are left with following problem, upon which TcT provides the
     certificate YES(O(1),O(n^1)).
     
     Strict DPs:
       { bfs^#(@queue, @futurequeue, @x) ->
         c_1(bfs#1^#(@queue, @futurequeue, @x))
       , bfs#1^#(::(@t, @ts), @futurequeue, @x) ->
         c_2(bfs#3^#(@t, @futurequeue, @ts, @x))
       , bfs#1^#(nil(), @futurequeue, @x) ->
         c_3(bfs#2^#(@futurequeue, @x))
       , bfs#2^#(::(@t, @ts), @x) ->
         c_6(bfs^#(reverse(::(@t, @ts)), nil(), @x)) }
     Weak DPs:
       { bfs#3^#(leaf(), @futurequeue, @ts, @x) ->
         c_4(bfs^#(@ts, @futurequeue, @x))
       , bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
         c_5(bfs#4^#(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y))
       , bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
         c_7(bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x))
       , bfs2^#(@t, @x) ->
         c_8(bfs2#1^#(dobfs(@t, @x), @x), dobfs^#(@t, @x))
       , bfs2#1^#(@t', @x) -> c_9(dobfs^#(@t', @x))
       , dobfs^#(@t, @x) -> c_10(bfs^#(::(@t, nil()), nil(), @x)) }
     Weak Trs:
       { #equal(@x, @y) -> #eq(@x, @y)
       , #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
         #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
       , #eq(::(@x_1, @x_2), nil()) -> #false()
       , #eq(::(@x_1, @x_2), leaf()) -> #false()
       , #eq(::(@x_1, @x_2), node(@y_1, @y_2, @y_3)) -> #false()
       , #eq(nil(), ::(@y_1, @y_2)) -> #false()
       , #eq(nil(), nil()) -> #true()
       , #eq(nil(), leaf()) -> #false()
       , #eq(nil(), node(@y_1, @y_2, @y_3)) -> #false()
       , #eq(leaf(), ::(@y_1, @y_2)) -> #false()
       , #eq(leaf(), nil()) -> #false()
       , #eq(leaf(), leaf()) -> #true()
       , #eq(leaf(), node(@y_1, @y_2, @y_3)) -> #false()
       , #eq(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2)) -> #false()
       , #eq(node(@x_1, @x_2, @x_3), nil()) -> #false()
       , #eq(node(@x_1, @x_2, @x_3), leaf()) -> #false()
       , #eq(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) ->
         #and(#eq(@x_1, @y_1), #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3)))
       , #eq(#0(), #0()) -> #true()
       , #eq(#0(), #neg(@y)) -> #false()
       , #eq(#0(), #pos(@y)) -> #false()
       , #eq(#0(), #s(@y)) -> #false()
       , #eq(#neg(@x), #0()) -> #false()
       , #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
       , #eq(#neg(@x), #pos(@y)) -> #false()
       , #eq(#pos(@x), #0()) -> #false()
       , #eq(#pos(@x), #neg(@y)) -> #false()
       , #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
       , #eq(#s(@x), #0()) -> #false()
       , #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
       , appendreverse(@toreverse, @sofar) ->
         appendreverse#1(@toreverse, @sofar)
       , appendreverse#1(::(@a, @as), @sofar) ->
         appendreverse(@as, ::(@a, @sofar))
       , appendreverse#1(nil(), @sofar) -> @sofar
       , bfs(@queue, @futurequeue, @x) -> bfs#1(@queue, @futurequeue, @x)
       , bfs#1(::(@t, @ts), @futurequeue, @x) ->
         bfs#3(@t, @futurequeue, @ts, @x)
       , bfs#1(nil(), @futurequeue, @x) -> bfs#2(@futurequeue, @x)
       , bfs#3(leaf(), @futurequeue, @ts, @x) ->
         bfs(@ts, @futurequeue, @x)
       , bfs#3(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
         bfs#4(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y)
       , bfs#2(::(@t, @ts), @x) -> bfs(reverse(::(@t, @ts)), nil(), @x)
       , bfs#2(nil(), @x) -> leaf()
       , reverse(@xs) -> appendreverse(@xs, nil())
       , bfs#4(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
         bfs(@ts, ::(@t2, ::(@t1, @futurequeue)), @x)
       , bfs#4(#true(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
         node(@y, @t1, @t2)
       , dobfs(@t, @x) -> bfs(::(@t, nil()), nil(), @x)
       , #and(#false(), #false()) -> #false()
       , #and(#false(), #true()) -> #false()
       , #and(#true(), #false()) -> #false()
       , #and(#true(), #true()) -> #true() }
     Obligation:
       innermost runtime complexity
     Answer:
       YES(O(1),O(n^1))
     
     We use the processor 'matrix interpretation of dimension 2' to
     orient following rules strictly.
     
     DPs:
       { 2: bfs#1^#(::(@t, @ts), @futurequeue, @x) ->
            c_2(bfs#3^#(@t, @futurequeue, @ts, @x)) }
     Trs:
       { #eq(nil(), nil()) -> #true()
       , #eq(leaf(), leaf()) -> #true()
       , #eq(#0(), #0()) -> #true()
       , bfs#4(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
         bfs(@ts, ::(@t2, ::(@t1, @futurequeue)), @x)
       , #and(#true(), #true()) -> #true() }
     
     Sub-proof:
     ----------
       The following argument positions are usable:
         Uargs(c_1) = {1}, Uargs(c_2) = {1}, Uargs(c_3) = {1},
         Uargs(c_4) = {1}, Uargs(c_5) = {1}, Uargs(c_6) = {1},
         Uargs(c_7) = {1}, Uargs(c_8) = {1, 2}, Uargs(c_9) = {1},
         Uargs(c_10) = {1}
       
       TcT has computed following constructor-based matrix interpretation
       satisfying not(EDA) and not(IDA(1)).
       
                              [#equal](x1, x2) = [0 0] x1 + [0]
                                                 [1 0]      [1]
                                                               
                                 [#eq](x1, x2) = [0 0] x1 + [2]
                                                 [1 1]      [1]
                                                               
                       [appendreverse](x1, x2) = [1 0] x1 + [1 0] x2 + [0]
                                                 [0 1]      [0 1]      [0]
                                                                          
                     [appendreverse#1](x1, x2) = [1 0] x1 + [1 0] x2 + [0]
                                                 [0 1]      [0 1]      [0]
                                                                          
                                  [::](x1, x2) = [1 0] x1 + [1 0] x2 + [1]
                                                 [1 0]      [0 1]      [0]
                                                                          
                                         [nil] = [0]
                                                 [0]
                                                    
                             [bfs](x1, x2, x3) = [0 1] x1 + [0 1] x2 + [0]
                                                 [0 0]      [0 0]      [0]
                                                                          
                           [bfs#1](x1, x2, x3) = [0 1] x1 + [0 1] x2 + [0]
                                                 [0 0]      [0 0]      [0]
                                                                          
                       [bfs#3](x1, x2, x3, x4) = [1 0] x1 + [0 1] x2 + [0
                                                                        1] x3 + [0]
                                                 [0 0]      [0 0]      [0
                                                                        0]      [0]
                                                                                   
                               [bfs#2](x1, x2) = [0 1] x1 + [0]
                                                 [0 0]      [0]
                                                               
                                 [reverse](x1) = [1 0] x1 + [0]
                                                 [0 1]      [0]
                                                               
                                        [leaf] = [0]
                                                 [0]
                                                    
                            [node](x1, x2, x3) = [1 0] x2 + [1 0] x3 + [2]
                                                 [0 0]      [0 0]      [0]
                                                                          
           [bfs#4](x1, x2, x3, x4, x5, x6, x7) = [0 1] x2 + [1 0] x3 + [1
                                                                        0] x4 + [0 1] x5 + [2]
                                                 [0 0]      [0 0]      [0
                                                                        0]      [0 0]      [0]
                                                                                              
                                      [#false] = [2]
                                                 [0]
                                                    
                                       [#true] = [0]
                                                 [0]
                                                    
                               [dobfs](x1, x2) = [1 0] x1 + [0]
                                                 [0 0]      [0]
                                                               
                                [#and](x1, x2) = [2]
                                                 [0]
                                                    
                                          [#0] = [1]
                                                 [2]
                                                    
                                    [#neg](x1) = [0 0] x1 + [0]
                                                 [1 1]      [0]
                                                               
                                    [#pos](x1) = [0 0] x1 + [0]
                                                 [1 1]      [0]
                                                               
                                      [#s](x1) = [1 0] x1 + [0]
                                                 [0 1]      [0]
                                                               
                            [#equal^#](x1, x2) = [0]
                                                 [0]
                                                    
                               [#eq^#](x1, x2) = [0]
                                                 [0]
                                                    
                     [appendreverse^#](x1, x2) = [0]
                                                 [0]
                                                    
                   [appendreverse#1^#](x1, x2) = [0]
                                                 [0]
                                                    
                           [bfs^#](x1, x2, x3) = [1 0] x1 + [1 0] x2 + [0]
                                                 [0 0]      [0 0]      [0]
                                                                          
                         [bfs#1^#](x1, x2, x3) = [1 0] x1 + [1 0] x2 + [0]
                                                 [0 0]      [0 0]      [0]
                                                                          
                     [bfs#3^#](x1, x2, x3, x4) = [1 0] x1 + [1 0] x2 + [1
                                                                        0] x3 + [0]
                                                 [0 0]      [0 0]      [0
                                                                        0]      [0]
                                                                                   
                             [bfs#2^#](x1, x2) = [1 0] x1 + [0]
                                                 [0 0]      [0]
                                                               
         [bfs#4^#](x1, x2, x3, x4, x5, x6, x7) = [1 0] x2 + [1 0] x3 + [1
                                                                        0] x4 + [1 0] x5 + [2]
                                                 [0 0]      [0 0]      [0
                                                                        0]      [0 0]      [0]
                                                                                              
                               [reverse^#](x1) = [0]
                                                 [0]
                                                    
                              [bfs2^#](x1, x2) = [2 0] x1 + [1 0] x2 + [2]
                                                 [1 1]      [2 2]      [1]
                                                                          
                            [bfs2#1^#](x1, x2) = [1 0] x1 + [1]
                                                 [0 0]      [0]
                                                               
                             [dobfs^#](x1, x2) = [1 0] x1 + [1]
                                                 [0 2]      [0]
                                                               
                               [dfs^#](x1, x2) = [0]
                                                 [0]
                                                    
                             [dfs#1^#](x1, x2) = [0]
                                                 [0]
                                                    
                     [dfs#2^#](x1, x2, x3, x4) = [0]
                                                 [0]
                                                    
             [dfs#3^#](x1, x2, x3, x4, x5, x6) = [0]
                                                 [0]
                                                    
                             [dodfs^#](x1, x2) = [0]
                                                 [0]
                                                    
                              [#and^#](x1, x2) = [0]
                                                 [0]
                                                    
                                     [c_3](x1) = [0]
                                                 [0]
                                                    
                                     [c_4](x1) = [0]
                                                 [0]
                                                    
                                     [c_5](x1) = [0]
                                                 [0]
                                                    
                                     [c_6](x1) = [0]
                                                 [0]
                                                    
                                     [c_7](x1) = [0]
                                                 [0]
                                                    
                                 [c_8](x1, x2) = [0]
                                                 [0]
                                                    
                                     [c_9](x1) = [0]
                                                 [0]
                                                    
                                [c_11](x1, x2) = [0]
                                                 [0]
                                                    
                                    [c_12](x1) = [0]
                                                 [0]
                                                    
                                    [c_13](x1) = [0]
                                                 [0]
                                                    
                                           [c] = [0]
                                                 [0]
                                                    
                                     [c_1](x1) = [1 0] x1 + [0]
                                                 [0 0]      [0]
                                                               
                                     [c_2](x1) = [1 0] x1 + [0]
                                                 [0 0]      [0]
                                                               
                                     [c_3](x1) = [1 0] x1 + [0]
                                                 [0 0]      [0]
                                                               
                                     [c_4](x1) = [1 0] x1 + [0]
                                                 [0 0]      [0]
                                                               
                                     [c_5](x1) = [1 0] x1 + [0]
                                                 [0 0]      [0]
                                                               
                                     [c_6](x1) = [1 1] x1 + [0]
                                                 [0 0]      [0]
                                                               
                                     [c_7](x1) = [1 0] x1 + [0]
                                                 [0 0]      [0]
                                                               
                                 [c_8](x1, x2) = [1 0] x1 + [1 0] x2 + [0]
                                                 [0 0]      [0 0]      [0]
                                                                          
                                     [c_9](x1) = [1 0] x1 + [0]
                                                 [0 0]      [0]
                                                               
                                    [c_10](x1) = [1 0] x1 + [0]
                                                 [0 0]      [0]
       
       This order satisfies following ordering constraints
       
                            [#eq(::(@x_1, @x_2), ::(@y_1, @y_2))] =  [0 0] @x_1 + [0 0] @x_2 + [2]                                      
                                                                     [2 0]        [1 1]        [2]                                      
                                                                  >= [2]                                                                
                                                                     [0]                                                                
                                                                  =  [#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))]                           
                                                                                                                                        
                                     [#eq(::(@x_1, @x_2), nil())] =  [0 0] @x_1 + [0 0] @x_2 + [2]                                      
                                                                     [2 0]        [1 1]        [2]                                      
                                                                  >= [2]                                                                
                                                                     [0]                                                                
                                                                  =  [#false()]                                                         
                                                                                                                                        
                                    [#eq(::(@x_1, @x_2), leaf())] =  [0 0] @x_1 + [0 0] @x_2 + [2]                                      
                                                                     [2 0]        [1 1]        [2]                                      
                                                                  >= [2]                                                                
                                                                     [0]                                                                
                                                                  =  [#false()]                                                         
                                                                                                                                        
                    [#eq(::(@x_1, @x_2), node(@y_1, @y_2, @y_3))] =  [0 0] @x_1 + [0 0] @x_2 + [2]                                      
                                                                     [2 0]        [1 1]        [2]                                      
                                                                  >= [2]                                                                
                                                                     [0]                                                                
                                                                  =  [#false()]                                                         
                                                                                                                                        
                                     [#eq(nil(), ::(@y_1, @y_2))] =  [2]                                                                
                                                                     [1]                                                                
                                                                  >= [2]                                                                
                                                                     [0]                                                                
                                                                  =  [#false()]                                                         
                                                                                                                                        
                                              [#eq(nil(), nil())] =  [2]                                                                
                                                                     [1]                                                                
                                                                  >  [0]                                                                
                                                                     [0]                                                                
                                                                  =  [#true()]                                                          
                                                                                                                                        
                                             [#eq(nil(), leaf())] =  [2]                                                                
                                                                     [1]                                                                
                                                                  >= [2]                                                                
                                                                     [0]                                                                
                                                                  =  [#false()]                                                         
                                                                                                                                        
                             [#eq(nil(), node(@y_1, @y_2, @y_3))] =  [2]                                                                
                                                                     [1]                                                                
                                                                  >= [2]                                                                
                                                                     [0]                                                                
                                                                  =  [#false()]                                                         
                                                                                                                                        
                                    [#eq(leaf(), ::(@y_1, @y_2))] =  [2]                                                                
                                                                     [1]                                                                
                                                                  >= [2]                                                                
                                                                     [0]                                                                
                                                                  =  [#false()]                                                         
                                                                                                                                        
                                             [#eq(leaf(), nil())] =  [2]                                                                
                                                                     [1]                                                                
                                                                  >= [2]                                                                
                                                                     [0]                                                                
                                                                  =  [#false()]                                                         
                                                                                                                                        
                                            [#eq(leaf(), leaf())] =  [2]                                                                
                                                                     [1]                                                                
                                                                  >  [0]                                                                
                                                                     [0]                                                                
                                                                  =  [#true()]                                                          
                                                                                                                                        
                            [#eq(leaf(), node(@y_1, @y_2, @y_3))] =  [2]                                                                
                                                                     [1]                                                                
                                                                  >= [2]                                                                
                                                                     [0]                                                                
                                                                  =  [#false()]                                                         
                                                                                                                                        
                    [#eq(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2))] =  [0 0] @x_2 + [0 0] @x_3 + [2]                                      
                                                                     [1 0]        [1 0]        [3]                                      
                                                                  >= [2]                                                                
                                                                     [0]                                                                
                                                                  =  [#false()]                                                         
                                                                                                                                        
                             [#eq(node(@x_1, @x_2, @x_3), nil())] =  [0 0] @x_2 + [0 0] @x_3 + [2]                                      
                                                                     [1 0]        [1 0]        [3]                                      
                                                                  >= [2]                                                                
                                                                     [0]                                                                
                                                                  =  [#false()]                                                         
                                                                                                                                        
                            [#eq(node(@x_1, @x_2, @x_3), leaf())] =  [0 0] @x_2 + [0 0] @x_3 + [2]                                      
                                                                     [1 0]        [1 0]        [3]                                      
                                                                  >= [2]                                                                
                                                                     [0]                                                                
                                                                  =  [#false()]                                                         
                                                                                                                                        
            [#eq(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3))] =  [0 0] @x_2 + [0 0] @x_3 + [2]                                      
                                                                     [1 0]        [1 0]        [3]                                      
                                                                  >= [2]                                                                
                                                                     [0]                                                                
                                                                  =  [#and(#eq(@x_1, @y_1), #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3)))]    
                                                                                                                                        
                                                [#eq(#0(), #0())] =  [2]                                                                
                                                                     [4]                                                                
                                                                  >  [0]                                                                
                                                                     [0]                                                                
                                                                  =  [#true()]                                                          
                                                                                                                                        
                                            [#eq(#0(), #neg(@y))] =  [2]                                                                
                                                                     [4]                                                                
                                                                  >= [2]                                                                
                                                                     [0]                                                                
                                                                  =  [#false()]                                                         
                                                                                                                                        
                                            [#eq(#0(), #pos(@y))] =  [2]                                                                
                                                                     [4]                                                                
                                                                  >= [2]                                                                
                                                                     [0]                                                                
                                                                  =  [#false()]                                                         
                                                                                                                                        
                                              [#eq(#0(), #s(@y))] =  [2]                                                                
                                                                     [4]                                                                
                                                                  >= [2]                                                                
                                                                     [0]                                                                
                                                                  =  [#false()]                                                         
                                                                                                                                        
                                            [#eq(#neg(@x), #0())] =  [0 0] @x + [2]                                                     
                                                                     [1 1]      [1]                                                     
                                                                  >= [2]                                                                
                                                                     [0]                                                                
                                                                  =  [#false()]                                                         
                                                                                                                                        
                                        [#eq(#neg(@x), #neg(@y))] =  [0 0] @x + [2]                                                     
                                                                     [1 1]      [1]                                                     
                                                                  >= [0 0] @x + [2]                                                     
                                                                     [1 1]      [1]                                                     
                                                                  =  [#eq(@x, @y)]                                                      
                                                                                                                                        
                                        [#eq(#neg(@x), #pos(@y))] =  [0 0] @x + [2]                                                     
                                                                     [1 1]      [1]                                                     
                                                                  >= [2]                                                                
                                                                     [0]                                                                
                                                                  =  [#false()]                                                         
                                                                                                                                        
                                            [#eq(#pos(@x), #0())] =  [0 0] @x + [2]                                                     
                                                                     [1 1]      [1]                                                     
                                                                  >= [2]                                                                
                                                                     [0]                                                                
                                                                  =  [#false()]                                                         
                                                                                                                                        
                                        [#eq(#pos(@x), #neg(@y))] =  [0 0] @x + [2]                                                     
                                                                     [1 1]      [1]                                                     
                                                                  >= [2]                                                                
                                                                     [0]                                                                
                                                                  =  [#false()]                                                         
                                                                                                                                        
                                        [#eq(#pos(@x), #pos(@y))] =  [0 0] @x + [2]                                                     
                                                                     [1 1]      [1]                                                     
                                                                  >= [0 0] @x + [2]                                                     
                                                                     [1 1]      [1]                                                     
                                                                  =  [#eq(@x, @y)]                                                      
                                                                                                                                        
                                              [#eq(#s(@x), #0())] =  [0 0] @x + [2]                                                     
                                                                     [1 1]      [1]                                                     
                                                                  >= [2]                                                                
                                                                     [0]                                                                
                                                                  =  [#false()]                                                         
                                                                                                                                        
                                            [#eq(#s(@x), #s(@y))] =  [0 0] @x + [2]                                                     
                                                                     [1 1]      [1]                                                     
                                                                  >= [0 0] @x + [2]                                                     
                                                                     [1 1]      [1]                                                     
                                                                  =  [#eq(@x, @y)]                                                      
                                                                                                                                        
                              [appendreverse(@toreverse, @sofar)] =  [1 0] @sofar + [1 0] @toreverse + [0]                              
                                                                     [0 1]          [0 1]              [0]                              
                                                                  >= [1 0] @sofar + [1 0] @toreverse + [0]                              
                                                                     [0 1]          [0 1]              [0]                              
                                                                  =  [appendreverse#1(@toreverse, @sofar)]                              
                                                                                                                                        
                           [appendreverse#1(::(@a, @as), @sofar)] =  [1 0] @a + [1 0] @as + [1 0] @sofar + [1]                          
                                                                     [1 0]      [0 1]       [0 1]          [0]                          
                                                                  >= [1 0] @a + [1 0] @as + [1 0] @sofar + [1]                          
                                                                     [1 0]      [0 1]       [0 1]          [0]                          
                                                                  =  [appendreverse(@as, ::(@a, @sofar))]                               
                                                                                                                                        
                                 [appendreverse#1(nil(), @sofar)] =  [1 0] @sofar + [0]                                                 
                                                                     [0 1]          [0]                                                 
                                                                  >= [1 0] @sofar + [0]                                                 
                                                                     [0 1]          [0]                                                 
                                                                  =  [@sofar]                                                           
                                                                                                                                        
                                  [bfs(@queue, @futurequeue, @x)] =  [0 1] @futurequeue + [0 1] @queue + [0]                            
                                                                     [0 0]                [0 0]          [0]                            
                                                                  >= [0 1] @futurequeue + [0 1] @queue + [0]                            
                                                                     [0 0]                [0 0]          [0]                            
                                                                  =  [bfs#1(@queue, @futurequeue, @x)]                                  
                                                                                                                                        
                           [bfs#1(::(@t, @ts), @futurequeue, @x)] =  [0 1] @futurequeue + [1 0] @t + [0 1] @ts + [0]                    
                                                                     [0 0]                [0 0]      [0 0]       [0]                    
                                                                  >= [0 1] @futurequeue + [1 0] @t + [0 1] @ts + [0]                    
                                                                     [0 0]                [0 0]      [0 0]       [0]                    
                                                                  =  [bfs#3(@t, @futurequeue, @ts, @x)]                                 
                                                                                                                                        
                                 [bfs#1(nil(), @futurequeue, @x)] =  [0 1] @futurequeue + [0]                                           
                                                                     [0 0]                [0]                                           
                                                                  >= [0 1] @futurequeue + [0]                                           
                                                                     [0 0]                [0]                                           
                                                                  =  [bfs#2(@futurequeue, @x)]                                          
                                                                                                                                        
                           [bfs#3(leaf(), @futurequeue, @ts, @x)] =  [0 1] @futurequeue + [0 1] @ts + [0]                               
                                                                     [0 0]                [0 0]       [0]                               
                                                                  >= [0 1] @futurequeue + [0 1] @ts + [0]                               
                                                                     [0 0]                [0 0]       [0]                               
                                                                  =  [bfs(@ts, @futurequeue, @x)]                                       
                                                                                                                                        
               [bfs#3(node(@y, @t1, @t2), @futurequeue, @ts, @x)] =  [0 1] @futurequeue + [1 0] @t1 + [1 0] @t2 + [0 1] @ts + [2]       
                                                                     [0 0]                [0 0]       [0 0]       [0 0]       [0]       
                                                                  >= [0 1] @futurequeue + [1 0] @t1 + [1 0] @t2 + [0 1] @ts + [2]       
                                                                     [0 0]                [0 0]       [0 0]       [0 0]       [0]       
                                                                  =  [bfs#4(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y)]       
                                                                                                                                        
                                         [bfs#2(::(@t, @ts), @x)] =  [1 0] @t + [0 1] @ts + [0]                                         
                                                                     [0 0]      [0 0]       [0]                                         
                                                                  >= [1 0] @t + [0 1] @ts + [0]                                         
                                                                     [0 0]      [0 0]       [0]                                         
                                                                  =  [bfs(reverse(::(@t, @ts)), nil(), @x)]                             
                                                                                                                                        
                                               [bfs#2(nil(), @x)] =  [0]                                                                
                                                                     [0]                                                                
                                                                  >= [0]                                                                
                                                                     [0]                                                                
                                                                  =  [leaf()]                                                           
                                                                                                                                        
                                                   [reverse(@xs)] =  [1 0] @xs + [0]                                                    
                                                                     [0 1]       [0]                                                    
                                                                  >= [1 0] @xs + [0]                                                    
                                                                     [0 1]       [0]                                                    
                                                                  =  [appendreverse(@xs, nil())]                                        
                                                                                                                                        
           [bfs#4(#false(), @futurequeue, @t1, @t2, @ts, @x, @y)] =  [0 1] @futurequeue + [1 0] @t1 + [1 0] @t2 + [0 1] @ts + [2]       
                                                                     [0 0]                [0 0]       [0 0]       [0 0]       [0]       
                                                                  >  [0 1] @futurequeue + [1 0] @t1 + [1 0] @t2 + [0 1] @ts + [0]       
                                                                     [0 0]                [0 0]       [0 0]       [0 0]       [0]       
                                                                  =  [bfs(@ts, ::(@t2, ::(@t1, @futurequeue)), @x)]                     
                                                                                                                                        
            [bfs#4(#true(), @futurequeue, @t1, @t2, @ts, @x, @y)] =  [0 1] @futurequeue + [1 0] @t1 + [1 0] @t2 + [0 1] @ts + [2]       
                                                                     [0 0]                [0 0]       [0 0]       [0 0]       [0]       
                                                                  >= [1 0] @t1 + [1 0] @t2 + [2]                                        
                                                                     [0 0]       [0 0]       [0]                                        
                                                                  =  [node(@y, @t1, @t2)]                                               
                                                                                                                                        
                                                  [dobfs(@t, @x)] =  [1 0] @t + [0]                                                     
                                                                     [0 0]      [0]                                                     
                                                                  >= [1 0] @t + [0]                                                     
                                                                     [0 0]      [0]                                                     
                                                                  =  [bfs(::(@t, nil()), nil(), @x)]                                    
                                                                                                                                        
                                       [#and(#false(), #false())] =  [2]                                                                
                                                                     [0]                                                                
                                                                  >= [2]                                                                
                                                                     [0]                                                                
                                                                  =  [#false()]                                                         
                                                                                                                                        
                                        [#and(#false(), #true())] =  [2]                                                                
                                                                     [0]                                                                
                                                                  >= [2]                                                                
                                                                     [0]                                                                
                                                                  =  [#false()]                                                         
                                                                                                                                        
                                        [#and(#true(), #false())] =  [2]                                                                
                                                                     [0]                                                                
                                                                  >= [2]                                                                
                                                                     [0]                                                                
                                                                  =  [#false()]                                                         
                                                                                                                                        
                                         [#and(#true(), #true())] =  [2]                                                                
                                                                     [0]                                                                
                                                                  >  [0]                                                                
                                                                     [0]                                                                
                                                                  =  [#true()]                                                          
                                                                                                                                        
                                [bfs^#(@queue, @futurequeue, @x)] =  [1 0] @futurequeue + [1 0] @queue + [0]                            
                                                                     [0 0]                [0 0]          [0]                            
                                                                  >= [1 0] @futurequeue + [1 0] @queue + [0]                            
                                                                     [0 0]                [0 0]          [0]                            
                                                                  =  [c_1(bfs#1^#(@queue, @futurequeue, @x))]                           
                                                                                                                                        
                         [bfs#1^#(::(@t, @ts), @futurequeue, @x)] =  [1 0] @futurequeue + [1 0] @t + [1 0] @ts + [1]                    
                                                                     [0 0]                [0 0]      [0 0]       [0]                    
                                                                  >  [1 0] @futurequeue + [1 0] @t + [1 0] @ts + [0]                    
                                                                     [0 0]                [0 0]      [0 0]       [0]                    
                                                                  =  [c_2(bfs#3^#(@t, @futurequeue, @ts, @x))]                          
                                                                                                                                        
                               [bfs#1^#(nil(), @futurequeue, @x)] =  [1 0] @futurequeue + [0]                                           
                                                                     [0 0]                [0]                                           
                                                                  >= [1 0] @futurequeue + [0]                                           
                                                                     [0 0]                [0]                                           
                                                                  =  [c_3(bfs#2^#(@futurequeue, @x))]                                   
                                                                                                                                        
                         [bfs#3^#(leaf(), @futurequeue, @ts, @x)] =  [1 0] @futurequeue + [1 0] @ts + [0]                               
                                                                     [0 0]                [0 0]       [0]                               
                                                                  >= [1 0] @futurequeue + [1 0] @ts + [0]                               
                                                                     [0 0]                [0 0]       [0]                               
                                                                  =  [c_4(bfs^#(@ts, @futurequeue, @x))]                                
                                                                                                                                        
             [bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x)] =  [1 0] @futurequeue + [1 0] @t1 + [1 0] @t2 + [1 0] @ts + [2]       
                                                                     [0 0]                [0 0]       [0 0]       [0 0]       [0]       
                                                                  >= [1 0] @futurequeue + [1 0] @t1 + [1 0] @t2 + [1 0] @ts + [2]       
                                                                     [0 0]                [0 0]       [0 0]       [0 0]       [0]       
                                                                  =  [c_5(bfs#4^#(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y))]
                                                                                                                                        
                                       [bfs#2^#(::(@t, @ts), @x)] =  [1 0] @t + [1 0] @ts + [1]                                         
                                                                     [0 0]      [0 0]       [0]                                         
                                                                  >= [1 0] @t + [1 0] @ts + [1]                                         
                                                                     [0 0]      [0 0]       [0]                                         
                                                                  =  [c_6(bfs^#(reverse(::(@t, @ts)), nil(), @x))]                      
                                                                                                                                        
         [bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y)] =  [1 0] @futurequeue + [1 0] @t1 + [1 0] @t2 + [1 0] @ts + [2]       
                                                                     [0 0]                [0 0]       [0 0]       [0 0]       [0]       
                                                                  >= [1 0] @futurequeue + [1 0] @t1 + [1 0] @t2 + [1 0] @ts + [2]       
                                                                     [0 0]                [0 0]       [0 0]       [0 0]       [0]       
                                                                  =  [c_7(bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x))]              
                                                                                                                                        
                                                 [bfs2^#(@t, @x)] =  [2 0] @t + [1 0] @x + [2]                                          
                                                                     [1 1]      [2 2]      [1]                                          
                                                                  >= [2 0] @t + [2]                                                     
                                                                     [0 0]      [0]                                                     
                                                                  =  [c_8(bfs2#1^#(dobfs(@t, @x), @x), dobfs^#(@t, @x))]                
                                                                                                                                        
                                              [bfs2#1^#(@t', @x)] =  [1 0] @t' + [1]                                                    
                                                                     [0 0]       [0]                                                    
                                                                  >= [1 0] @t' + [1]                                                    
                                                                     [0 0]       [0]                                                    
                                                                  =  [c_9(dobfs^#(@t', @x))]                                            
                                                                                                                                        
                                                [dobfs^#(@t, @x)] =  [1 0] @t + [1]                                                     
                                                                     [0 2]      [0]                                                     
                                                                  >= [1 0] @t + [1]                                                     
                                                                     [0 0]      [0]                                                     
                                                                  =  [c_10(bfs^#(::(@t, nil()), nil(), @x))]                            
                                                                                                                                        
     
     Consider the set of all dependency pairs
     
     DPs:
       { 1: bfs^#(@queue, @futurequeue, @x) ->
            c_1(bfs#1^#(@queue, @futurequeue, @x))
       , 2: bfs#1^#(::(@t, @ts), @futurequeue, @x) ->
            c_2(bfs#3^#(@t, @futurequeue, @ts, @x))
       , 3: bfs#1^#(nil(), @futurequeue, @x) ->
            c_3(bfs#2^#(@futurequeue, @x))
       , 4: bfs#2^#(::(@t, @ts), @x) ->
            c_6(bfs^#(reverse(::(@t, @ts)), nil(), @x))
       , 5: bfs#3^#(leaf(), @futurequeue, @ts, @x) ->
            c_4(bfs^#(@ts, @futurequeue, @x))
       , 6: bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
            c_5(bfs#4^#(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y))
       , 7: bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
            c_7(bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x))
       , 8: bfs2^#(@t, @x) ->
            c_8(bfs2#1^#(dobfs(@t, @x), @x), dobfs^#(@t, @x))
       , 9: bfs2#1^#(@t', @x) -> c_9(dobfs^#(@t', @x))
       , 10: dobfs^#(@t, @x) -> c_10(bfs^#(::(@t, nil()), nil(), @x)) }
     
     Processor 'matrix interpretation of dimension 2' induces the
     complexity certificate YES(?,O(n^1)) on application of dependency
     pairs {2}. These cover all (indirect) predecessors of dependency
     pairs {2,5,6,7,8,9,10}, their number of application is equally
     bounded. The dependency pairs are shifted into the corresponding
     weak component(s).
     
     
     We are left with following problem, upon which TcT provides the
     certificate YES(O(1),O(n^1)).
     
     Strict DPs:
       { bfs^#(@queue, @futurequeue, @x) ->
         c_1(bfs#1^#(@queue, @futurequeue, @x))
       , bfs#1^#(nil(), @futurequeue, @x) ->
         c_3(bfs#2^#(@futurequeue, @x))
       , bfs#2^#(::(@t, @ts), @x) ->
         c_6(bfs^#(reverse(::(@t, @ts)), nil(), @x)) }
     Weak DPs:
       { bfs#1^#(::(@t, @ts), @futurequeue, @x) ->
         c_2(bfs#3^#(@t, @futurequeue, @ts, @x))
       , bfs#3^#(leaf(), @futurequeue, @ts, @x) ->
         c_4(bfs^#(@ts, @futurequeue, @x))
       , bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
         c_5(bfs#4^#(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y))
       , bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
         c_7(bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x))
       , bfs2^#(@t, @x) ->
         c_8(bfs2#1^#(dobfs(@t, @x), @x), dobfs^#(@t, @x))
       , bfs2#1^#(@t', @x) -> c_9(dobfs^#(@t', @x))
       , dobfs^#(@t, @x) -> c_10(bfs^#(::(@t, nil()), nil(), @x)) }
     Weak Trs:
       { #equal(@x, @y) -> #eq(@x, @y)
       , #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
         #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
       , #eq(::(@x_1, @x_2), nil()) -> #false()
       , #eq(::(@x_1, @x_2), leaf()) -> #false()
       , #eq(::(@x_1, @x_2), node(@y_1, @y_2, @y_3)) -> #false()
       , #eq(nil(), ::(@y_1, @y_2)) -> #false()
       , #eq(nil(), nil()) -> #true()
       , #eq(nil(), leaf()) -> #false()
       , #eq(nil(), node(@y_1, @y_2, @y_3)) -> #false()
       , #eq(leaf(), ::(@y_1, @y_2)) -> #false()
       , #eq(leaf(), nil()) -> #false()
       , #eq(leaf(), leaf()) -> #true()
       , #eq(leaf(), node(@y_1, @y_2, @y_3)) -> #false()
       , #eq(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2)) -> #false()
       , #eq(node(@x_1, @x_2, @x_3), nil()) -> #false()
       , #eq(node(@x_1, @x_2, @x_3), leaf()) -> #false()
       , #eq(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) ->
         #and(#eq(@x_1, @y_1), #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3)))
       , #eq(#0(), #0()) -> #true()
       , #eq(#0(), #neg(@y)) -> #false()
       , #eq(#0(), #pos(@y)) -> #false()
       , #eq(#0(), #s(@y)) -> #false()
       , #eq(#neg(@x), #0()) -> #false()
       , #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
       , #eq(#neg(@x), #pos(@y)) -> #false()
       , #eq(#pos(@x), #0()) -> #false()
       , #eq(#pos(@x), #neg(@y)) -> #false()
       , #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
       , #eq(#s(@x), #0()) -> #false()
       , #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
       , appendreverse(@toreverse, @sofar) ->
         appendreverse#1(@toreverse, @sofar)
       , appendreverse#1(::(@a, @as), @sofar) ->
         appendreverse(@as, ::(@a, @sofar))
       , appendreverse#1(nil(), @sofar) -> @sofar
       , bfs(@queue, @futurequeue, @x) -> bfs#1(@queue, @futurequeue, @x)
       , bfs#1(::(@t, @ts), @futurequeue, @x) ->
         bfs#3(@t, @futurequeue, @ts, @x)
       , bfs#1(nil(), @futurequeue, @x) -> bfs#2(@futurequeue, @x)
       , bfs#3(leaf(), @futurequeue, @ts, @x) ->
         bfs(@ts, @futurequeue, @x)
       , bfs#3(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
         bfs#4(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y)
       , bfs#2(::(@t, @ts), @x) -> bfs(reverse(::(@t, @ts)), nil(), @x)
       , bfs#2(nil(), @x) -> leaf()
       , reverse(@xs) -> appendreverse(@xs, nil())
       , bfs#4(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
         bfs(@ts, ::(@t2, ::(@t1, @futurequeue)), @x)
       , bfs#4(#true(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
         node(@y, @t1, @t2)
       , dobfs(@t, @x) -> bfs(::(@t, nil()), nil(), @x)
       , #and(#false(), #false()) -> #false()
       , #and(#false(), #true()) -> #false()
       , #and(#true(), #false()) -> #false()
       , #and(#true(), #true()) -> #true() }
     Obligation:
       innermost runtime complexity
     Answer:
       YES(O(1),O(n^1))
     
     We use the processor 'matrix interpretation of dimension 2' to
     orient following rules strictly.
     
     DPs:
       { 3: bfs#2^#(::(@t, @ts), @x) ->
            c_6(bfs^#(reverse(::(@t, @ts)), nil(), @x))
       , 10: dobfs^#(@t, @x) -> c_10(bfs^#(::(@t, nil()), nil(), @x)) }
     Trs:
       { #eq(nil(), nil()) -> #true()
       , #eq(leaf(), leaf()) -> #true()
       , #eq(#0(), #0()) -> #true()
       , #and(#true(), #true()) -> #true() }
     
     Sub-proof:
     ----------
       The following argument positions are usable:
         Uargs(c_1) = {1}, Uargs(c_2) = {1}, Uargs(c_3) = {1},
         Uargs(c_4) = {1}, Uargs(c_5) = {1}, Uargs(c_6) = {1},
         Uargs(c_7) = {1}, Uargs(c_8) = {1, 2}, Uargs(c_9) = {1},
         Uargs(c_10) = {1}
       
       TcT has computed following constructor-based matrix interpretation
       satisfying not(EDA) and not(IDA(1)).
       
                              [#equal](x1, x2) = [0 1] x2 + [2]
                                                 [1 0]      [2]
                                                               
                                 [#eq](x1, x2) = [2]
                                                 [2]
                                                    
                       [appendreverse](x1, x2) = [1 0] x1 + [1 0] x2 + [0]
                                                 [0 1]      [0 1]      [0]
                                                                          
                     [appendreverse#1](x1, x2) = [1 0] x1 + [1 0] x2 + [0]
                                                 [0 1]      [0 1]      [0]
                                                                          
                                  [::](x1, x2) = [0 0] x1 + [1 0] x2 + [1]
                                                 [1 1]      [0 1]      [0]
                                                                          
                                         [nil] = [0]
                                                 [0]
                                                    
                             [bfs](x1, x2, x3) = [0 0] x1 + [0 0] x2 + [0]
                                                 [0 1]      [0 1]      [0]
                                                                          
                           [bfs#1](x1, x2, x3) = [0 0] x1 + [0 0] x2 + [0]
                                                 [0 1]      [0 1]      [0]
                                                                          
                       [bfs#3](x1, x2, x3, x4) = [0 0] x1 + [0 0] x2 + [0
                                                                        0] x3 + [0]
                                                 [0 1]      [0 1]      [0
                                                                        1]      [0]
                                                                                   
                               [bfs#2](x1, x2) = [0 0] x1 + [0]
                                                 [0 1]      [0]
                                                               
                                 [reverse](x1) = [1 0] x1 + [0]
                                                 [0 1]      [0]
                                                               
                                        [leaf] = [0]
                                                 [0]
                                                    
                            [node](x1, x2, x3) = [0 0] x1 + [0 0] x2 + [0
                                                                        0] x3 + [0]
                                                 [1 1]      [1 1]      [1
                                                                        1]      [2]
                                                                                   
           [bfs#4](x1, x2, x3, x4, x5, x6, x7) = [0 0] x2 + [0 0] x3 + [0
                                                                        0] x4 + [0 0] x5 + [0
                                                                                            0] x7 + [0]
                                                 [0 1]      [1 1]      [1
                                                                        1]      [0 1]      [1
                                                                                            1]      [2]
                                                                                                       
                                      [#false] = [2]
                                                 [2]
                                                    
                                       [#true] = [0]
                                                 [2]
                                                    
                               [dobfs](x1, x2) = [0 0] x1 + [0]
                                                 [1 1]      [0]
                                                               
                                [#and](x1, x2) = [0 1] x2 + [0]
                                                 [0 0]      [2]
                                                               
                                          [#0] = [2]
                                                 [2]
                                                    
                                    [#neg](x1) = [1 0] x1 + [0]
                                                 [0 1]      [2]
                                                               
                                    [#pos](x1) = [1 0] x1 + [0]
                                                 [0 1]      [2]
                                                               
                                      [#s](x1) = [1 0] x1 + [0]
                                                 [0 1]      [2]
                                                               
                            [#equal^#](x1, x2) = [0]
                                                 [0]
                                                    
                               [#eq^#](x1, x2) = [0]
                                                 [0]
                                                    
                     [appendreverse^#](x1, x2) = [0]
                                                 [0]
                                                    
                   [appendreverse#1^#](x1, x2) = [0]
                                                 [0]
                                                    
                           [bfs^#](x1, x2, x3) = [0 1] x1 + [1 1] x2 + [0]
                                                 [0 0]      [0 1]      [0]
                                                                          
                         [bfs#1^#](x1, x2, x3) = [0 1] x1 + [1 1] x2 + [0]
                                                 [0 0]      [0 0]      [0]
                                                                          
                     [bfs#3^#](x1, x2, x3, x4) = [1 1] x1 + [1 1] x2 + [0
                                                                        1] x3 + [0]
                                                 [0 0]      [0 0]      [0
                                                                        1]      [0]
                                                                                   
                             [bfs#2^#](x1, x2) = [1 1] x1 + [0]
                                                 [0 0]      [0]
                                                               
         [bfs#4^#](x1, x2, x3, x4, x5, x6, x7) = [1 0] x1 + [1 1] x2 + [1
                                                                        1] x3 + [1 1] x4 + [0
                                                                                            1] x5 + [1
                                                                                                     0] x7 + [0]
                                                 [0 0]      [0 0]      [0
                                                                        0]      [1 1]      [0
                                                                                            0]      [0
                                                                                                     0]      [0]
                                                                                                                
                               [reverse^#](x1) = [0]
                                                 [0]
                                                    
                              [bfs2^#](x1, x2) = [2 2] x1 + [2 2] x2 + [2]
                                                 [2 1]      [1 1]      [1]
                                                                          
                            [bfs2#1^#](x1, x2) = [2 1] x1 + [0 0] x2 + [1]
                                                 [0 0]      [1 2]      [0]
                                                                          
                             [dobfs^#](x1, x2) = [1 1] x1 + [1]
                                                 [0 1]      [1]
                                                               
                               [dfs^#](x1, x2) = [0]
                                                 [0]
                                                    
                             [dfs#1^#](x1, x2) = [0]
                                                 [0]
                                                    
                     [dfs#2^#](x1, x2, x3, x4) = [0]
                                                 [0]
                                                    
             [dfs#3^#](x1, x2, x3, x4, x5, x6) = [0]
                                                 [0]
                                                    
                             [dodfs^#](x1, x2) = [0]
                                                 [0]
                                                    
                              [#and^#](x1, x2) = [0]
                                                 [0]
                                                    
                                     [c_3](x1) = [0]
                                                 [0]
                                                    
                                     [c_4](x1) = [0]
                                                 [0]
                                                    
                                     [c_5](x1) = [0]
                                                 [0]
                                                    
                                     [c_6](x1) = [0]
                                                 [0]
                                                    
                                     [c_7](x1) = [0]
                                                 [0]
                                                    
                                 [c_8](x1, x2) = [0]
                                                 [0]
                                                    
                                     [c_9](x1) = [0]
                                                 [0]
                                                    
                                [c_11](x1, x2) = [0]
                                                 [0]
                                                    
                                    [c_12](x1) = [0]
                                                 [0]
                                                    
                                    [c_13](x1) = [0]
                                                 [0]
                                                    
                                           [c] = [0]
                                                 [0]
                                                    
                                     [c_1](x1) = [1 0] x1 + [0]
                                                 [0 0]      [0]
                                                               
                                     [c_2](x1) = [1 0] x1 + [0]
                                                 [0 0]      [0]
                                                               
                                     [c_3](x1) = [1 0] x1 + [0]
                                                 [0 0]      [0]
                                                               
                                     [c_4](x1) = [1 0] x1 + [0]
                                                 [0 0]      [0]
                                                               
                                     [c_5](x1) = [1 0] x1 + [0]
                                                 [0 0]      [0]
                                                               
                                     [c_6](x1) = [1 1] x1 + [0]
                                                 [0 0]      [0]
                                                               
                                     [c_7](x1) = [1 0] x1 + [0]
                                                 [0 0]      [0]
                                                               
                                 [c_8](x1, x2) = [1 1] x1 + [1 0] x2 + [0]
                                                 [0 0]      [0 0]      [0]
                                                                          
                                     [c_9](x1) = [1 0] x1 + [0]
                                                 [0 0]      [0]
                                                               
                                    [c_10](x1) = [1 0] x1 + [0]
                                                 [0 0]      [0]
       
       This order satisfies following ordering constraints
       
                                                 [#equal(@x, @y)] =  [0 1] @y + [2]                                                       
                                                                     [1 0]      [2]                                                       
                                                                  >= [2]                                                                  
                                                                     [2]                                                                  
                                                                  =  [#eq(@x, @y)]                                                        
                                                                                                                                          
                            [#eq(::(@x_1, @x_2), ::(@y_1, @y_2))] =  [2]                                                                  
                                                                     [2]                                                                  
                                                                  >= [2]                                                                  
                                                                     [2]                                                                  
                                                                  =  [#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))]                             
                                                                                                                                          
                                     [#eq(::(@x_1, @x_2), nil())] =  [2]                                                                  
                                                                     [2]                                                                  
                                                                  >= [2]                                                                  
                                                                     [2]                                                                  
                                                                  =  [#false()]                                                           
                                                                                                                                          
                                    [#eq(::(@x_1, @x_2), leaf())] =  [2]                                                                  
                                                                     [2]                                                                  
                                                                  >= [2]                                                                  
                                                                     [2]                                                                  
                                                                  =  [#false()]                                                           
                                                                                                                                          
                    [#eq(::(@x_1, @x_2), node(@y_1, @y_2, @y_3))] =  [2]                                                                  
                                                                     [2]                                                                  
                                                                  >= [2]                                                                  
                                                                     [2]                                                                  
                                                                  =  [#false()]                                                           
                                                                                                                                          
                                     [#eq(nil(), ::(@y_1, @y_2))] =  [2]                                                                  
                                                                     [2]                                                                  
                                                                  >= [2]                                                                  
                                                                     [2]                                                                  
                                                                  =  [#false()]                                                           
                                                                                                                                          
                                              [#eq(nil(), nil())] =  [2]                                                                  
                                                                     [2]                                                                  
                                                                  >  [0]                                                                  
                                                                     [2]                                                                  
                                                                  =  [#true()]                                                            
                                                                                                                                          
                                             [#eq(nil(), leaf())] =  [2]                                                                  
                                                                     [2]                                                                  
                                                                  >= [2]                                                                  
                                                                     [2]                                                                  
                                                                  =  [#false()]                                                           
                                                                                                                                          
                             [#eq(nil(), node(@y_1, @y_2, @y_3))] =  [2]                                                                  
                                                                     [2]                                                                  
                                                                  >= [2]                                                                  
                                                                     [2]                                                                  
                                                                  =  [#false()]                                                           
                                                                                                                                          
                                    [#eq(leaf(), ::(@y_1, @y_2))] =  [2]                                                                  
                                                                     [2]                                                                  
                                                                  >= [2]                                                                  
                                                                     [2]                                                                  
                                                                  =  [#false()]                                                           
                                                                                                                                          
                                             [#eq(leaf(), nil())] =  [2]                                                                  
                                                                     [2]                                                                  
                                                                  >= [2]                                                                  
                                                                     [2]                                                                  
                                                                  =  [#false()]                                                           
                                                                                                                                          
                                            [#eq(leaf(), leaf())] =  [2]                                                                  
                                                                     [2]                                                                  
                                                                  >  [0]                                                                  
                                                                     [2]                                                                  
                                                                  =  [#true()]                                                            
                                                                                                                                          
                            [#eq(leaf(), node(@y_1, @y_2, @y_3))] =  [2]                                                                  
                                                                     [2]                                                                  
                                                                  >= [2]                                                                  
                                                                     [2]                                                                  
                                                                  =  [#false()]                                                           
                                                                                                                                          
                    [#eq(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2))] =  [2]                                                                  
                                                                     [2]                                                                  
                                                                  >= [2]                                                                  
                                                                     [2]                                                                  
                                                                  =  [#false()]                                                           
                                                                                                                                          
                             [#eq(node(@x_1, @x_2, @x_3), nil())] =  [2]                                                                  
                                                                     [2]                                                                  
                                                                  >= [2]                                                                  
                                                                     [2]                                                                  
                                                                  =  [#false()]                                                           
                                                                                                                                          
                            [#eq(node(@x_1, @x_2, @x_3), leaf())] =  [2]                                                                  
                                                                     [2]                                                                  
                                                                  >= [2]                                                                  
                                                                     [2]                                                                  
                                                                  =  [#false()]                                                           
                                                                                                                                          
            [#eq(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3))] =  [2]                                                                  
                                                                     [2]                                                                  
                                                                  >= [2]                                                                  
                                                                     [2]                                                                  
                                                                  =  [#and(#eq(@x_1, @y_1), #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3)))]      
                                                                                                                                          
                                                [#eq(#0(), #0())] =  [2]                                                                  
                                                                     [2]                                                                  
                                                                  >  [0]                                                                  
                                                                     [2]                                                                  
                                                                  =  [#true()]                                                            
                                                                                                                                          
                                            [#eq(#0(), #neg(@y))] =  [2]                                                                  
                                                                     [2]                                                                  
                                                                  >= [2]                                                                  
                                                                     [2]                                                                  
                                                                  =  [#false()]                                                           
                                                                                                                                          
                                            [#eq(#0(), #pos(@y))] =  [2]                                                                  
                                                                     [2]                                                                  
                                                                  >= [2]                                                                  
                                                                     [2]                                                                  
                                                                  =  [#false()]                                                           
                                                                                                                                          
                                              [#eq(#0(), #s(@y))] =  [2]                                                                  
                                                                     [2]                                                                  
                                                                  >= [2]                                                                  
                                                                     [2]                                                                  
                                                                  =  [#false()]                                                           
                                                                                                                                          
                                            [#eq(#neg(@x), #0())] =  [2]                                                                  
                                                                     [2]                                                                  
                                                                  >= [2]                                                                  
                                                                     [2]                                                                  
                                                                  =  [#false()]                                                           
                                                                                                                                          
                                        [#eq(#neg(@x), #neg(@y))] =  [2]                                                                  
                                                                     [2]                                                                  
                                                                  >= [2]                                                                  
                                                                     [2]                                                                  
                                                                  =  [#eq(@x, @y)]                                                        
                                                                                                                                          
                                        [#eq(#neg(@x), #pos(@y))] =  [2]                                                                  
                                                                     [2]                                                                  
                                                                  >= [2]                                                                  
                                                                     [2]                                                                  
                                                                  =  [#false()]                                                           
                                                                                                                                          
                                            [#eq(#pos(@x), #0())] =  [2]                                                                  
                                                                     [2]                                                                  
                                                                  >= [2]                                                                  
                                                                     [2]                                                                  
                                                                  =  [#false()]                                                           
                                                                                                                                          
                                        [#eq(#pos(@x), #neg(@y))] =  [2]                                                                  
                                                                     [2]                                                                  
                                                                  >= [2]                                                                  
                                                                     [2]                                                                  
                                                                  =  [#false()]                                                           
                                                                                                                                          
                                        [#eq(#pos(@x), #pos(@y))] =  [2]                                                                  
                                                                     [2]                                                                  
                                                                  >= [2]                                                                  
                                                                     [2]                                                                  
                                                                  =  [#eq(@x, @y)]                                                        
                                                                                                                                          
                                              [#eq(#s(@x), #0())] =  [2]                                                                  
                                                                     [2]                                                                  
                                                                  >= [2]                                                                  
                                                                     [2]                                                                  
                                                                  =  [#false()]                                                           
                                                                                                                                          
                                            [#eq(#s(@x), #s(@y))] =  [2]                                                                  
                                                                     [2]                                                                  
                                                                  >= [2]                                                                  
                                                                     [2]                                                                  
                                                                  =  [#eq(@x, @y)]                                                        
                                                                                                                                          
                              [appendreverse(@toreverse, @sofar)] =  [1 0] @sofar + [1 0] @toreverse + [0]                                
                                                                     [0 1]          [0 1]              [0]                                
                                                                  >= [1 0] @sofar + [1 0] @toreverse + [0]                                
                                                                     [0 1]          [0 1]              [0]                                
                                                                  =  [appendreverse#1(@toreverse, @sofar)]                                
                                                                                                                                          
                           [appendreverse#1(::(@a, @as), @sofar)] =  [0 0] @a + [1 0] @as + [1 0] @sofar + [1]                            
                                                                     [1 1]      [0 1]       [0 1]          [0]                            
                                                                  >= [0 0] @a + [1 0] @as + [1 0] @sofar + [1]                            
                                                                     [1 1]      [0 1]       [0 1]          [0]                            
                                                                  =  [appendreverse(@as, ::(@a, @sofar))]                                 
                                                                                                                                          
                                 [appendreverse#1(nil(), @sofar)] =  [1 0] @sofar + [0]                                                   
                                                                     [0 1]          [0]                                                   
                                                                  >= [1 0] @sofar + [0]                                                   
                                                                     [0 1]          [0]                                                   
                                                                  =  [@sofar]                                                             
                                                                                                                                          
                                  [bfs(@queue, @futurequeue, @x)] =  [0 0] @futurequeue + [0 0] @queue + [0]                              
                                                                     [0 1]                [0 1]          [0]                              
                                                                  >= [0 0] @futurequeue + [0 0] @queue + [0]                              
                                                                     [0 1]                [0 1]          [0]                              
                                                                  =  [bfs#1(@queue, @futurequeue, @x)]                                    
                                                                                                                                          
                           [bfs#1(::(@t, @ts), @futurequeue, @x)] =  [0 0] @futurequeue + [0 0] @t + [0 0] @ts + [0]                      
                                                                     [0 1]                [1 1]      [0 1]       [0]                      
                                                                  >= [0 0] @futurequeue + [0 0] @t + [0 0] @ts + [0]                      
                                                                     [0 1]                [0 1]      [0 1]       [0]                      
                                                                  =  [bfs#3(@t, @futurequeue, @ts, @x)]                                   
                                                                                                                                          
                                 [bfs#1(nil(), @futurequeue, @x)] =  [0 0] @futurequeue + [0]                                             
                                                                     [0 1]                [0]                                             
                                                                  >= [0 0] @futurequeue + [0]                                             
                                                                     [0 1]                [0]                                             
                                                                  =  [bfs#2(@futurequeue, @x)]                                            
                                                                                                                                          
                           [bfs#3(leaf(), @futurequeue, @ts, @x)] =  [0 0] @futurequeue + [0 0] @ts + [0]                                 
                                                                     [0 1]                [0 1]       [0]                                 
                                                                  >= [0 0] @futurequeue + [0 0] @ts + [0]                                 
                                                                     [0 1]                [0 1]       [0]                                 
                                                                  =  [bfs(@ts, @futurequeue, @x)]                                         
                                                                                                                                          
               [bfs#3(node(@y, @t1, @t2), @futurequeue, @ts, @x)] =  [0 0] @futurequeue + [0 0] @t1 + [0 0] @t2 + [0 0] @ts + [0          
                                                                                                                               0] @y + [0]
                                                                     [0 1]                [1 1]       [1 1]       [0 1]       [1          
                                                                                                                               1]      [2]
                                                                  >= [0 0] @futurequeue + [0 0] @t1 + [0 0] @t2 + [0 0] @ts + [0          
                                                                                                                               0] @y + [0]
                                                                     [0 1]                [1 1]       [1 1]       [0 1]       [1          
                                                                                                                               1]      [2]
                                                                  =  [bfs#4(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y)]         
                                                                                                                                          
                                         [bfs#2(::(@t, @ts), @x)] =  [0 0] @t + [0 0] @ts + [0]                                           
                                                                     [1 1]      [0 1]       [0]                                           
                                                                  >= [0 0] @t + [0 0] @ts + [0]                                           
                                                                     [1 1]      [0 1]       [0]                                           
                                                                  =  [bfs(reverse(::(@t, @ts)), nil(), @x)]                               
                                                                                                                                          
                                               [bfs#2(nil(), @x)] =  [0]                                                                  
                                                                     [0]                                                                  
                                                                  >= [0]                                                                  
                                                                     [0]                                                                  
                                                                  =  [leaf()]                                                             
                                                                                                                                          
                                                   [reverse(@xs)] =  [1 0] @xs + [0]                                                      
                                                                     [0 1]       [0]                                                      
                                                                  >= [1 0] @xs + [0]                                                      
                                                                     [0 1]       [0]                                                      
                                                                  =  [appendreverse(@xs, nil())]                                          
                                                                                                                                          
           [bfs#4(#false(), @futurequeue, @t1, @t2, @ts, @x, @y)] =  [0 0] @futurequeue + [0 0] @t1 + [0 0] @t2 + [0 0] @ts + [0          
                                                                                                                               0] @y + [0]
                                                                     [0 1]                [1 1]       [1 1]       [0 1]       [1          
                                                                                                                               1]      [2]
                                                                  >= [0 0] @futurequeue + [0 0] @t1 + [0 0] @t2 + [0 0] @ts + [0]         
                                                                     [0 1]                [1 1]       [1 1]       [0 1]       [0]         
                                                                  =  [bfs(@ts, ::(@t2, ::(@t1, @futurequeue)), @x)]                       
                                                                                                                                          
            [bfs#4(#true(), @futurequeue, @t1, @t2, @ts, @x, @y)] =  [0 0] @futurequeue + [0 0] @t1 + [0 0] @t2 + [0 0] @ts + [0          
                                                                                                                               0] @y + [0]
                                                                     [0 1]                [1 1]       [1 1]       [0 1]       [1          
                                                                                                                               1]      [2]
                                                                  >= [0 0] @t1 + [0 0] @t2 + [0 0] @y + [0]                               
                                                                     [1 1]       [1 1]       [1 1]      [2]                               
                                                                  =  [node(@y, @t1, @t2)]                                                 
                                                                                                                                          
                                                  [dobfs(@t, @x)] =  [0 0] @t + [0]                                                       
                                                                     [1 1]      [0]                                                       
                                                                  >= [0 0] @t + [0]                                                       
                                                                     [1 1]      [0]                                                       
                                                                  =  [bfs(::(@t, nil()), nil(), @x)]                                      
                                                                                                                                          
                                       [#and(#false(), #false())] =  [2]                                                                  
                                                                     [2]                                                                  
                                                                  >= [2]                                                                  
                                                                     [2]                                                                  
                                                                  =  [#false()]                                                           
                                                                                                                                          
                                        [#and(#false(), #true())] =  [2]                                                                  
                                                                     [2]                                                                  
                                                                  >= [2]                                                                  
                                                                     [2]                                                                  
                                                                  =  [#false()]                                                           
                                                                                                                                          
                                        [#and(#true(), #false())] =  [2]                                                                  
                                                                     [2]                                                                  
                                                                  >= [2]                                                                  
                                                                     [2]                                                                  
                                                                  =  [#false()]                                                           
                                                                                                                                          
                                         [#and(#true(), #true())] =  [2]                                                                  
                                                                     [2]                                                                  
                                                                  >  [0]                                                                  
                                                                     [2]                                                                  
                                                                  =  [#true()]                                                            
                                                                                                                                          
                                [bfs^#(@queue, @futurequeue, @x)] =  [1 1] @futurequeue + [0 1] @queue + [0]                              
                                                                     [0 1]                [0 0]          [0]                              
                                                                  >= [1 1] @futurequeue + [0 1] @queue + [0]                              
                                                                     [0 0]                [0 0]          [0]                              
                                                                  =  [c_1(bfs#1^#(@queue, @futurequeue, @x))]                             
                                                                                                                                          
                         [bfs#1^#(::(@t, @ts), @futurequeue, @x)] =  [1 1] @futurequeue + [1 1] @t + [0 1] @ts + [0]                      
                                                                     [0 0]                [0 0]      [0 0]       [0]                      
                                                                  >= [1 1] @futurequeue + [1 1] @t + [0 1] @ts + [0]                      
                                                                     [0 0]                [0 0]      [0 0]       [0]                      
                                                                  =  [c_2(bfs#3^#(@t, @futurequeue, @ts, @x))]                            
                                                                                                                                          
                               [bfs#1^#(nil(), @futurequeue, @x)] =  [1 1] @futurequeue + [0]                                             
                                                                     [0 0]                [0]                                             
                                                                  >= [1 1] @futurequeue + [0]                                             
                                                                     [0 0]                [0]                                             
                                                                  =  [c_3(bfs#2^#(@futurequeue, @x))]                                     
                                                                                                                                          
                         [bfs#3^#(leaf(), @futurequeue, @ts, @x)] =  [1 1] @futurequeue + [0 1] @ts + [0]                                 
                                                                     [0 0]                [0 1]       [0]                                 
                                                                  >= [1 1] @futurequeue + [0 1] @ts + [0]                                 
                                                                     [0 0]                [0 0]       [0]                                 
                                                                  =  [c_4(bfs^#(@ts, @futurequeue, @x))]                                  
                                                                                                                                          
             [bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x)] =  [1 1] @futurequeue + [1 1] @t1 + [1 1] @t2 + [0 1] @ts + [1          
                                                                                                                               1] @y + [2]
                                                                     [0 0]                [0 0]       [0 0]       [0 1]       [0          
                                                                                                                               0]      [0]
                                                                  >= [1 1] @futurequeue + [1 1] @t1 + [1 1] @t2 + [0 1] @ts + [1          
                                                                                                                               1] @y + [2]
                                                                     [0 0]                [0 0]       [0 0]       [0 0]       [0          
                                                                                                                               0]      [0]
                                                                  =  [c_5(bfs#4^#(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y))]  
                                                                                                                                          
                                       [bfs#2^#(::(@t, @ts), @x)] =  [1 1] @t + [1 1] @ts + [1]                                           
                                                                     [0 0]      [0 0]       [0]                                           
                                                                  >  [1 1] @t + [0 1] @ts + [0]                                           
                                                                     [0 0]      [0 0]       [0]                                           
                                                                  =  [c_6(bfs^#(reverse(::(@t, @ts)), nil(), @x))]                        
                                                                                                                                          
         [bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y)] =  [1 1] @futurequeue + [1 1] @t1 + [1 1] @t2 + [0 1] @ts + [1          
                                                                                                                               0] @y + [2]
                                                                     [0 0]                [0 0]       [1 1]       [0 0]       [0          
                                                                                                                               0]      [0]
                                                                  >= [1 1] @futurequeue + [1 1] @t1 + [1 1] @t2 + [0 1] @ts + [2]         
                                                                     [0 0]                [0 0]       [0 0]       [0 0]       [0]         
                                                                  =  [c_7(bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x))]                
                                                                                                                                          
                                                 [bfs2^#(@t, @x)] =  [2 2] @t + [2 2] @x + [2]                                            
                                                                     [2 1]      [1 1]      [1]                                            
                                                                  >= [2 2] @t + [1 2] @x + [2]                                            
                                                                     [0 0]      [0 0]      [0]                                            
                                                                  =  [c_8(bfs2#1^#(dobfs(@t, @x), @x), dobfs^#(@t, @x))]                  
                                                                                                                                          
                                              [bfs2#1^#(@t', @x)] =  [2 1] @t' + [0 0] @x + [1]                                           
                                                                     [0 0]       [1 2]      [0]                                           
                                                                  >= [1 1] @t' + [1]                                                      
                                                                     [0 0]       [0]                                                      
                                                                  =  [c_9(dobfs^#(@t', @x))]                                              
                                                                                                                                          
                                                [dobfs^#(@t, @x)] =  [1 1] @t + [1]                                                       
                                                                     [0 1]      [1]                                                       
                                                                  >  [1 1] @t + [0]                                                       
                                                                     [0 0]      [0]                                                       
                                                                  =  [c_10(bfs^#(::(@t, nil()), nil(), @x))]                              
                                                                                                                                          
     
     Consider the set of all dependency pairs
     
     DPs:
       { 1: bfs^#(@queue, @futurequeue, @x) ->
            c_1(bfs#1^#(@queue, @futurequeue, @x))
       , 2: bfs#1^#(nil(), @futurequeue, @x) ->
            c_3(bfs#2^#(@futurequeue, @x))
       , 3: bfs#2^#(::(@t, @ts), @x) ->
            c_6(bfs^#(reverse(::(@t, @ts)), nil(), @x))
       , 4: bfs#1^#(::(@t, @ts), @futurequeue, @x) ->
            c_2(bfs#3^#(@t, @futurequeue, @ts, @x))
       , 5: bfs#3^#(leaf(), @futurequeue, @ts, @x) ->
            c_4(bfs^#(@ts, @futurequeue, @x))
       , 6: bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
            c_5(bfs#4^#(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y))
       , 7: bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
            c_7(bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x))
       , 8: bfs2^#(@t, @x) ->
            c_8(bfs2#1^#(dobfs(@t, @x), @x), dobfs^#(@t, @x))
       , 9: bfs2#1^#(@t', @x) -> c_9(dobfs^#(@t', @x))
       , 10: dobfs^#(@t, @x) -> c_10(bfs^#(::(@t, nil()), nil(), @x)) }
     
     Processor 'matrix interpretation of dimension 2' induces the
     complexity certificate YES(?,O(n^1)) on application of dependency
     pairs {3,10}. These cover all (indirect) predecessors of dependency
     pairs {3,8,9,10}, their number of application is equally bounded.
     The dependency pairs are shifted into the corresponding weak
     component(s).
     
     
     We are left with following problem, upon which TcT provides the
     certificate YES(O(1),O(n^1)).
     
     Strict DPs:
       { bfs^#(@queue, @futurequeue, @x) ->
         c_1(bfs#1^#(@queue, @futurequeue, @x))
       , bfs#1^#(nil(), @futurequeue, @x) ->
         c_3(bfs#2^#(@futurequeue, @x)) }
     Weak DPs:
       { bfs#1^#(::(@t, @ts), @futurequeue, @x) ->
         c_2(bfs#3^#(@t, @futurequeue, @ts, @x))
       , bfs#3^#(leaf(), @futurequeue, @ts, @x) ->
         c_4(bfs^#(@ts, @futurequeue, @x))
       , bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
         c_5(bfs#4^#(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y))
       , bfs#2^#(::(@t, @ts), @x) ->
         c_6(bfs^#(reverse(::(@t, @ts)), nil(), @x))
       , bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
         c_7(bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x))
       , bfs2^#(@t, @x) ->
         c_8(bfs2#1^#(dobfs(@t, @x), @x), dobfs^#(@t, @x))
       , bfs2#1^#(@t', @x) -> c_9(dobfs^#(@t', @x))
       , dobfs^#(@t, @x) -> c_10(bfs^#(::(@t, nil()), nil(), @x)) }
     Weak Trs:
       { #equal(@x, @y) -> #eq(@x, @y)
       , #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
         #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
       , #eq(::(@x_1, @x_2), nil()) -> #false()
       , #eq(::(@x_1, @x_2), leaf()) -> #false()
       , #eq(::(@x_1, @x_2), node(@y_1, @y_2, @y_3)) -> #false()
       , #eq(nil(), ::(@y_1, @y_2)) -> #false()
       , #eq(nil(), nil()) -> #true()
       , #eq(nil(), leaf()) -> #false()
       , #eq(nil(), node(@y_1, @y_2, @y_3)) -> #false()
       , #eq(leaf(), ::(@y_1, @y_2)) -> #false()
       , #eq(leaf(), nil()) -> #false()
       , #eq(leaf(), leaf()) -> #true()
       , #eq(leaf(), node(@y_1, @y_2, @y_3)) -> #false()
       , #eq(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2)) -> #false()
       , #eq(node(@x_1, @x_2, @x_3), nil()) -> #false()
       , #eq(node(@x_1, @x_2, @x_3), leaf()) -> #false()
       , #eq(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) ->
         #and(#eq(@x_1, @y_1), #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3)))
       , #eq(#0(), #0()) -> #true()
       , #eq(#0(), #neg(@y)) -> #false()
       , #eq(#0(), #pos(@y)) -> #false()
       , #eq(#0(), #s(@y)) -> #false()
       , #eq(#neg(@x), #0()) -> #false()
       , #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
       , #eq(#neg(@x), #pos(@y)) -> #false()
       , #eq(#pos(@x), #0()) -> #false()
       , #eq(#pos(@x), #neg(@y)) -> #false()
       , #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
       , #eq(#s(@x), #0()) -> #false()
       , #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
       , appendreverse(@toreverse, @sofar) ->
         appendreverse#1(@toreverse, @sofar)
       , appendreverse#1(::(@a, @as), @sofar) ->
         appendreverse(@as, ::(@a, @sofar))
       , appendreverse#1(nil(), @sofar) -> @sofar
       , bfs(@queue, @futurequeue, @x) -> bfs#1(@queue, @futurequeue, @x)
       , bfs#1(::(@t, @ts), @futurequeue, @x) ->
         bfs#3(@t, @futurequeue, @ts, @x)
       , bfs#1(nil(), @futurequeue, @x) -> bfs#2(@futurequeue, @x)
       , bfs#3(leaf(), @futurequeue, @ts, @x) ->
         bfs(@ts, @futurequeue, @x)
       , bfs#3(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
         bfs#4(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y)
       , bfs#2(::(@t, @ts), @x) -> bfs(reverse(::(@t, @ts)), nil(), @x)
       , bfs#2(nil(), @x) -> leaf()
       , reverse(@xs) -> appendreverse(@xs, nil())
       , bfs#4(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
         bfs(@ts, ::(@t2, ::(@t1, @futurequeue)), @x)
       , bfs#4(#true(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
         node(@y, @t1, @t2)
       , dobfs(@t, @x) -> bfs(::(@t, nil()), nil(), @x)
       , #and(#false(), #false()) -> #false()
       , #and(#false(), #true()) -> #false()
       , #and(#true(), #false()) -> #false()
       , #and(#true(), #true()) -> #true() }
     Obligation:
       innermost runtime complexity
     Answer:
       YES(O(1),O(n^1))
     
     We use the processor 'matrix interpretation of dimension 2' to
     orient following rules strictly.
     
     DPs:
       { 4: bfs#3^#(leaf(), @futurequeue, @ts, @x) ->
            c_4(bfs^#(@ts, @futurequeue, @x))
       , 6: bfs#2^#(::(@t, @ts), @x) ->
            c_6(bfs^#(reverse(::(@t, @ts)), nil(), @x))
       , 7: bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
            c_7(bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x)) }
     Trs:
       { #eq(nil(), nil()) -> #true()
       , #eq(leaf(), leaf()) -> #true()
       , #eq(#0(), #0()) -> #true()
       , appendreverse#1(nil(), @sofar) -> @sofar
       , bfs#3(leaf(), @futurequeue, @ts, @x) ->
         bfs(@ts, @futurequeue, @x)
       , bfs#3(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
         bfs#4(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y)
       , bfs#4(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
         bfs(@ts, ::(@t2, ::(@t1, @futurequeue)), @x)
       , #and(#true(), #true()) -> #true() }
     
     Sub-proof:
     ----------
       The following argument positions are usable:
         Uargs(c_1) = {1}, Uargs(c_2) = {1}, Uargs(c_3) = {1},
         Uargs(c_4) = {1}, Uargs(c_5) = {1}, Uargs(c_6) = {1},
         Uargs(c_7) = {1}, Uargs(c_8) = {1, 2}, Uargs(c_9) = {1},
         Uargs(c_10) = {1}
       
       TcT has computed following constructor-based matrix interpretation
       satisfying not(EDA) and not(IDA(1)).
       
                              [#equal](x1, x2) = [1]
                                                 [1]
                                                    
                                 [#eq](x1, x2) = [1]
                                                 [1]
                                                    
                       [appendreverse](x1, x2) = [2 0] x1 + [2 0] x2 + [2]
                                                 [0 1]      [0 1]      [0]
                                                                          
                     [appendreverse#1](x1, x2) = [2 0] x1 + [2 0] x2 + [2]
                                                 [0 1]      [0 1]      [0]
                                                                          
                                  [::](x1, x2) = [0 0] x1 + [1 0] x2 + [1]
                                                 [1 1]      [0 1]      [0]
                                                                          
                                         [nil] = [0]
                                                 [0]
                                                    
                             [bfs](x1, x2, x3) = [0 1] x1 + [0 1] x2 + [1]
                                                 [0 0]      [0 0]      [1]
                                                                          
                           [bfs#1](x1, x2, x3) = [0 1] x1 + [0 1] x2 + [1]
                                                 [0 0]      [0 0]      [1]
                                                                          
                       [bfs#3](x1, x2, x3, x4) = [1 1] x1 + [0 1] x2 + [0
                                                                        1] x3 + [1]
                                                 [0 0]      [0 0]      [0
                                                                        0]      [1]
                                                                                   
                               [bfs#2](x1, x2) = [0 1] x1 + [1]
                                                 [0 0]      [1]
                                                               
                                 [reverse](x1) = [2 0] x1 + [2]
                                                 [0 1]      [0]
                                                               
                                        [leaf] = [1]
                                                 [0]
                                                    
                            [node](x1, x2, x3) = [1 0] x1 + [1 1] x2 + [1
                                                                        1] x3 + [2]
                                                 [0 0]      [0 0]      [0
                                                                        0]      [1]
                                                                                   
           [bfs#4](x1, x2, x3, x4, x5, x6, x7) = [1 2] x1 + [0 1] x2 + [1
                                                                        1] x3 + [1 1] x4 + [0
                                                                                            1] x5 + [1
                                                                                                     0] x7 + [0]
                                                 [0 0]      [0 0]      [0
                                                                        0]      [0 0]      [0
                                                                                            0]      [0
                                                                                                     0]      [1]
                                                                                                                
                                      [#false] = [1]
                                                 [1]
                                                    
                                       [#true] = [0]
                                                 [1]
                                                    
                               [dobfs](x1, x2) = [1 1] x1 + [1]
                                                 [0 0]      [1]
                                                               
                                [#and](x1, x2) = [0 1] x1 + [0]
                                                 [0 1]      [0]
                                                               
                                          [#0] = [0]
                                                 [0]
                                                    
                                    [#neg](x1) = [1 0] x1 + [0]
                                                 [0 1]      [0]
                                                               
                                    [#pos](x1) = [1 0] x1 + [1]
                                                 [0 1]      [0]
                                                               
                                      [#s](x1) = [1 0] x1 + [0]
                                                 [0 1]      [0]
                                                               
                            [#equal^#](x1, x2) = [0]
                                                 [0]
                                                    
                               [#eq^#](x1, x2) = [0]
                                                 [0]
                                                    
                     [appendreverse^#](x1, x2) = [0]
                                                 [0]
                                                    
                   [appendreverse#1^#](x1, x2) = [0]
                                                 [0]
                                                    
                           [bfs^#](x1, x2, x3) = [0 1] x1 + [1 1] x2 + [0]
                                                 [1 0]      [0 0]      [0]
                                                                          
                         [bfs#1^#](x1, x2, x3) = [0 1] x1 + [1 1] x2 + [0]
                                                 [0 0]      [0 0]      [0]
                                                                          
                     [bfs#3^#](x1, x2, x3, x4) = [1 1] x1 + [1 1] x2 + [0
                                                                        1] x3 + [0]
                                                 [0 0]      [0 0]      [0
                                                                        0]      [0]
                                                                                   
                             [bfs#2^#](x1, x2) = [1 1] x1 + [0]
                                                 [0 0]      [0]
                                                               
         [bfs#4^#](x1, x2, x3, x4, x5, x6, x7) = [1 1] x1 + [1 1] x2 + [1
                                                                        1] x3 + [1 1] x4 + [0
                                                                                            1] x5 + [1]
                                                 [0 0]      [0 0]      [0
                                                                        0]      [0 0]      [0
                                                                                            0]      [0]
                                                                                                       
                               [reverse^#](x1) = [0]
                                                 [0]
                                                    
                              [bfs2^#](x1, x2) = [2 2] x1 + [2 2] x2 + [2]
                                                 [1 2]      [1 1]      [2]
                                                                          
                            [bfs2#1^#](x1, x2) = [1 1] x1 + [0 2] x2 + [0]
                                                 [0 0]      [0 0]      [0]
                                                                          
                             [dobfs^#](x1, x2) = [1 1] x1 + [0 0] x2 + [0]
                                                 [0 0]      [2 0]      [0]
                                                                          
                               [dfs^#](x1, x2) = [0]
                                                 [0]
                                                    
                             [dfs#1^#](x1, x2) = [0]
                                                 [0]
                                                    
                     [dfs#2^#](x1, x2, x3, x4) = [0]
                                                 [0]
                                                    
             [dfs#3^#](x1, x2, x3, x4, x5, x6) = [0]
                                                 [0]
                                                    
                             [dodfs^#](x1, x2) = [0]
                                                 [0]
                                                    
                              [#and^#](x1, x2) = [0]
                                                 [0]
                                                    
                                     [c_3](x1) = [0]
                                                 [0]
                                                    
                                     [c_4](x1) = [0]
                                                 [0]
                                                    
                                     [c_5](x1) = [0]
                                                 [0]
                                                    
                                     [c_6](x1) = [0]
                                                 [0]
                                                    
                                     [c_7](x1) = [0]
                                                 [0]
                                                    
                                 [c_8](x1, x2) = [0]
                                                 [0]
                                                    
                                     [c_9](x1) = [0]
                                                 [0]
                                                    
                                [c_11](x1, x2) = [0]
                                                 [0]
                                                    
                                    [c_12](x1) = [0]
                                                 [0]
                                                    
                                    [c_13](x1) = [0]
                                                 [0]
                                                    
                                           [c] = [0]
                                                 [0]
                                                    
                                     [c_1](x1) = [1 0] x1 + [0]
                                                 [0 0]      [0]
                                                               
                                     [c_2](x1) = [1 0] x1 + [0]
                                                 [0 0]      [0]
                                                               
                                     [c_3](x1) = [1 0] x1 + [0]
                                                 [0 0]      [0]
                                                               
                                     [c_4](x1) = [1 0] x1 + [0]
                                                 [0 0]      [0]
                                                               
                                     [c_5](x1) = [1 1] x1 + [0]
                                                 [0 0]      [0]
                                                               
                                     [c_6](x1) = [1 0] x1 + [0]
                                                 [0 0]      [0]
                                                               
                                     [c_7](x1) = [1 0] x1 + [0]
                                                 [0 0]      [0]
                                                               
                                 [c_8](x1, x2) = [1 0] x1 + [1 1] x2 + [0]
                                                 [0 0]      [0 0]      [0]
                                                                          
                                     [c_9](x1) = [1 0] x1 + [0]
                                                 [0 0]      [0]
                                                               
                                    [c_10](x1) = [1 0] x1 + [0]
                                                 [0 0]      [0]
       
       This order satisfies following ordering constraints
       
                                                 [#equal(@x, @y)] =  [1]                                                                  
                                                                     [1]                                                                  
                                                                  >= [1]                                                                  
                                                                     [1]                                                                  
                                                                  =  [#eq(@x, @y)]                                                        
                                                                                                                                          
                            [#eq(::(@x_1, @x_2), ::(@y_1, @y_2))] =  [1]                                                                  
                                                                     [1]                                                                  
                                                                  >= [1]                                                                  
                                                                     [1]                                                                  
                                                                  =  [#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))]                             
                                                                                                                                          
                                     [#eq(::(@x_1, @x_2), nil())] =  [1]                                                                  
                                                                     [1]                                                                  
                                                                  >= [1]                                                                  
                                                                     [1]                                                                  
                                                                  =  [#false()]                                                           
                                                                                                                                          
                                    [#eq(::(@x_1, @x_2), leaf())] =  [1]                                                                  
                                                                     [1]                                                                  
                                                                  >= [1]                                                                  
                                                                     [1]                                                                  
                                                                  =  [#false()]                                                           
                                                                                                                                          
                    [#eq(::(@x_1, @x_2), node(@y_1, @y_2, @y_3))] =  [1]                                                                  
                                                                     [1]                                                                  
                                                                  >= [1]                                                                  
                                                                     [1]                                                                  
                                                                  =  [#false()]                                                           
                                                                                                                                          
                                     [#eq(nil(), ::(@y_1, @y_2))] =  [1]                                                                  
                                                                     [1]                                                                  
                                                                  >= [1]                                                                  
                                                                     [1]                                                                  
                                                                  =  [#false()]                                                           
                                                                                                                                          
                                              [#eq(nil(), nil())] =  [1]                                                                  
                                                                     [1]                                                                  
                                                                  >  [0]                                                                  
                                                                     [1]                                                                  
                                                                  =  [#true()]                                                            
                                                                                                                                          
                                             [#eq(nil(), leaf())] =  [1]                                                                  
                                                                     [1]                                                                  
                                                                  >= [1]                                                                  
                                                                     [1]                                                                  
                                                                  =  [#false()]                                                           
                                                                                                                                          
                             [#eq(nil(), node(@y_1, @y_2, @y_3))] =  [1]                                                                  
                                                                     [1]                                                                  
                                                                  >= [1]                                                                  
                                                                     [1]                                                                  
                                                                  =  [#false()]                                                           
                                                                                                                                          
                                    [#eq(leaf(), ::(@y_1, @y_2))] =  [1]                                                                  
                                                                     [1]                                                                  
                                                                  >= [1]                                                                  
                                                                     [1]                                                                  
                                                                  =  [#false()]                                                           
                                                                                                                                          
                                             [#eq(leaf(), nil())] =  [1]                                                                  
                                                                     [1]                                                                  
                                                                  >= [1]                                                                  
                                                                     [1]                                                                  
                                                                  =  [#false()]                                                           
                                                                                                                                          
                                            [#eq(leaf(), leaf())] =  [1]                                                                  
                                                                     [1]                                                                  
                                                                  >  [0]                                                                  
                                                                     [1]                                                                  
                                                                  =  [#true()]                                                            
                                                                                                                                          
                            [#eq(leaf(), node(@y_1, @y_2, @y_3))] =  [1]                                                                  
                                                                     [1]                                                                  
                                                                  >= [1]                                                                  
                                                                     [1]                                                                  
                                                                  =  [#false()]                                                           
                                                                                                                                          
                    [#eq(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2))] =  [1]                                                                  
                                                                     [1]                                                                  
                                                                  >= [1]                                                                  
                                                                     [1]                                                                  
                                                                  =  [#false()]                                                           
                                                                                                                                          
                             [#eq(node(@x_1, @x_2, @x_3), nil())] =  [1]                                                                  
                                                                     [1]                                                                  
                                                                  >= [1]                                                                  
                                                                     [1]                                                                  
                                                                  =  [#false()]                                                           
                                                                                                                                          
                            [#eq(node(@x_1, @x_2, @x_3), leaf())] =  [1]                                                                  
                                                                     [1]                                                                  
                                                                  >= [1]                                                                  
                                                                     [1]                                                                  
                                                                  =  [#false()]                                                           
                                                                                                                                          
            [#eq(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3))] =  [1]                                                                  
                                                                     [1]                                                                  
                                                                  >= [1]                                                                  
                                                                     [1]                                                                  
                                                                  =  [#and(#eq(@x_1, @y_1), #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3)))]      
                                                                                                                                          
                                                [#eq(#0(), #0())] =  [1]                                                                  
                                                                     [1]                                                                  
                                                                  >  [0]                                                                  
                                                                     [1]                                                                  
                                                                  =  [#true()]                                                            
                                                                                                                                          
                                            [#eq(#0(), #neg(@y))] =  [1]                                                                  
                                                                     [1]                                                                  
                                                                  >= [1]                                                                  
                                                                     [1]                                                                  
                                                                  =  [#false()]                                                           
                                                                                                                                          
                                            [#eq(#0(), #pos(@y))] =  [1]                                                                  
                                                                     [1]                                                                  
                                                                  >= [1]                                                                  
                                                                     [1]                                                                  
                                                                  =  [#false()]                                                           
                                                                                                                                          
                                              [#eq(#0(), #s(@y))] =  [1]                                                                  
                                                                     [1]                                                                  
                                                                  >= [1]                                                                  
                                                                     [1]                                                                  
                                                                  =  [#false()]                                                           
                                                                                                                                          
                                            [#eq(#neg(@x), #0())] =  [1]                                                                  
                                                                     [1]                                                                  
                                                                  >= [1]                                                                  
                                                                     [1]                                                                  
                                                                  =  [#false()]                                                           
                                                                                                                                          
                                        [#eq(#neg(@x), #neg(@y))] =  [1]                                                                  
                                                                     [1]                                                                  
                                                                  >= [1]                                                                  
                                                                     [1]                                                                  
                                                                  =  [#eq(@x, @y)]                                                        
                                                                                                                                          
                                        [#eq(#neg(@x), #pos(@y))] =  [1]                                                                  
                                                                     [1]                                                                  
                                                                  >= [1]                                                                  
                                                                     [1]                                                                  
                                                                  =  [#false()]                                                           
                                                                                                                                          
                                            [#eq(#pos(@x), #0())] =  [1]                                                                  
                                                                     [1]                                                                  
                                                                  >= [1]                                                                  
                                                                     [1]                                                                  
                                                                  =  [#false()]                                                           
                                                                                                                                          
                                        [#eq(#pos(@x), #neg(@y))] =  [1]                                                                  
                                                                     [1]                                                                  
                                                                  >= [1]                                                                  
                                                                     [1]                                                                  
                                                                  =  [#false()]                                                           
                                                                                                                                          
                                        [#eq(#pos(@x), #pos(@y))] =  [1]                                                                  
                                                                     [1]                                                                  
                                                                  >= [1]                                                                  
                                                                     [1]                                                                  
                                                                  =  [#eq(@x, @y)]                                                        
                                                                                                                                          
                                              [#eq(#s(@x), #0())] =  [1]                                                                  
                                                                     [1]                                                                  
                                                                  >= [1]                                                                  
                                                                     [1]                                                                  
                                                                  =  [#false()]                                                           
                                                                                                                                          
                                            [#eq(#s(@x), #s(@y))] =  [1]                                                                  
                                                                     [1]                                                                  
                                                                  >= [1]                                                                  
                                                                     [1]                                                                  
                                                                  =  [#eq(@x, @y)]                                                        
                                                                                                                                          
                              [appendreverse(@toreverse, @sofar)] =  [2 0] @sofar + [2 0] @toreverse + [2]                                
                                                                     [0 1]          [0 1]              [0]                                
                                                                  >= [2 0] @sofar + [2 0] @toreverse + [2]                                
                                                                     [0 1]          [0 1]              [0]                                
                                                                  =  [appendreverse#1(@toreverse, @sofar)]                                
                                                                                                                                          
                           [appendreverse#1(::(@a, @as), @sofar)] =  [0 0] @a + [2 0] @as + [2 0] @sofar + [4]                            
                                                                     [1 1]      [0 1]       [0 1]          [0]                            
                                                                  >= [0 0] @a + [2 0] @as + [2 0] @sofar + [4]                            
                                                                     [1 1]      [0 1]       [0 1]          [0]                            
                                                                  =  [appendreverse(@as, ::(@a, @sofar))]                                 
                                                                                                                                          
                                 [appendreverse#1(nil(), @sofar)] =  [2 0] @sofar + [2]                                                   
                                                                     [0 1]          [0]                                                   
                                                                  >  [1 0] @sofar + [0]                                                   
                                                                     [0 1]          [0]                                                   
                                                                  =  [@sofar]                                                             
                                                                                                                                          
                                  [bfs(@queue, @futurequeue, @x)] =  [0 1] @futurequeue + [0 1] @queue + [1]                              
                                                                     [0 0]                [0 0]          [1]                              
                                                                  >= [0 1] @futurequeue + [0 1] @queue + [1]                              
                                                                     [0 0]                [0 0]          [1]                              
                                                                  =  [bfs#1(@queue, @futurequeue, @x)]                                    
                                                                                                                                          
                           [bfs#1(::(@t, @ts), @futurequeue, @x)] =  [0 1] @futurequeue + [1 1] @t + [0 1] @ts + [1]                      
                                                                     [0 0]                [0 0]      [0 0]       [1]                      
                                                                  >= [0 1] @futurequeue + [1 1] @t + [0 1] @ts + [1]                      
                                                                     [0 0]                [0 0]      [0 0]       [1]                      
                                                                  =  [bfs#3(@t, @futurequeue, @ts, @x)]                                   
                                                                                                                                          
                                 [bfs#1(nil(), @futurequeue, @x)] =  [0 1] @futurequeue + [1]                                             
                                                                     [0 0]                [1]                                             
                                                                  >= [0 1] @futurequeue + [1]                                             
                                                                     [0 0]                [1]                                             
                                                                  =  [bfs#2(@futurequeue, @x)]                                            
                                                                                                                                          
                           [bfs#3(leaf(), @futurequeue, @ts, @x)] =  [0 1] @futurequeue + [0 1] @ts + [2]                                 
                                                                     [0 0]                [0 0]       [1]                                 
                                                                  >  [0 1] @futurequeue + [0 1] @ts + [1]                                 
                                                                     [0 0]                [0 0]       [1]                                 
                                                                  =  [bfs(@ts, @futurequeue, @x)]                                         
                                                                                                                                          
               [bfs#3(node(@y, @t1, @t2), @futurequeue, @ts, @x)] =  [0 1] @futurequeue + [1 1] @t1 + [1 1] @t2 + [0 1] @ts + [1          
                                                                                                                               0] @y + [4]
                                                                     [0 0]                [0 0]       [0 0]       [0 0]       [0          
                                                                                                                               0]      [1]
                                                                  >  [0 1] @futurequeue + [1 1] @t1 + [1 1] @t2 + [0 1] @ts + [1          
                                                                                                                               0] @y + [3]
                                                                     [0 0]                [0 0]       [0 0]       [0 0]       [0          
                                                                                                                               0]      [1]
                                                                  =  [bfs#4(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y)]         
                                                                                                                                          
                                         [bfs#2(::(@t, @ts), @x)] =  [1 1] @t + [0 1] @ts + [1]                                           
                                                                     [0 0]      [0 0]       [1]                                           
                                                                  >= [1 1] @t + [0 1] @ts + [1]                                           
                                                                     [0 0]      [0 0]       [1]                                           
                                                                  =  [bfs(reverse(::(@t, @ts)), nil(), @x)]                               
                                                                                                                                          
                                               [bfs#2(nil(), @x)] =  [1]                                                                  
                                                                     [1]                                                                  
                                                                  >= [1]                                                                  
                                                                     [0]                                                                  
                                                                  =  [leaf()]                                                             
                                                                                                                                          
                                                   [reverse(@xs)] =  [2 0] @xs + [2]                                                      
                                                                     [0 1]       [0]                                                      
                                                                  >= [2 0] @xs + [2]                                                      
                                                                     [0 1]       [0]                                                      
                                                                  =  [appendreverse(@xs, nil())]                                          
                                                                                                                                          
           [bfs#4(#false(), @futurequeue, @t1, @t2, @ts, @x, @y)] =  [0 1] @futurequeue + [1 1] @t1 + [1 1] @t2 + [0 1] @ts + [1          
                                                                                                                               0] @y + [3]
                                                                     [0 0]                [0 0]       [0 0]       [0 0]       [0          
                                                                                                                               0]      [1]
                                                                  >  [0 1] @futurequeue + [1 1] @t1 + [1 1] @t2 + [0 1] @ts + [1]         
                                                                     [0 0]                [0 0]       [0 0]       [0 0]       [1]         
                                                                  =  [bfs(@ts, ::(@t2, ::(@t1, @futurequeue)), @x)]                       
                                                                                                                                          
            [bfs#4(#true(), @futurequeue, @t1, @t2, @ts, @x, @y)] =  [0 1] @futurequeue + [1 1] @t1 + [1 1] @t2 + [0 1] @ts + [1          
                                                                                                                               0] @y + [2]
                                                                     [0 0]                [0 0]       [0 0]       [0 0]       [0          
                                                                                                                               0]      [1]
                                                                  >= [1 1] @t1 + [1 1] @t2 + [1 0] @y + [2]                               
                                                                     [0 0]       [0 0]       [0 0]      [1]                               
                                                                  =  [node(@y, @t1, @t2)]                                                 
                                                                                                                                          
                                                  [dobfs(@t, @x)] =  [1 1] @t + [1]                                                       
                                                                     [0 0]      [1]                                                       
                                                                  >= [1 1] @t + [1]                                                       
                                                                     [0 0]      [1]                                                       
                                                                  =  [bfs(::(@t, nil()), nil(), @x)]                                      
                                                                                                                                          
                                       [#and(#false(), #false())] =  [1]                                                                  
                                                                     [1]                                                                  
                                                                  >= [1]                                                                  
                                                                     [1]                                                                  
                                                                  =  [#false()]                                                           
                                                                                                                                          
                                        [#and(#false(), #true())] =  [1]                                                                  
                                                                     [1]                                                                  
                                                                  >= [1]                                                                  
                                                                     [1]                                                                  
                                                                  =  [#false()]                                                           
                                                                                                                                          
                                        [#and(#true(), #false())] =  [1]                                                                  
                                                                     [1]                                                                  
                                                                  >= [1]                                                                  
                                                                     [1]                                                                  
                                                                  =  [#false()]                                                           
                                                                                                                                          
                                         [#and(#true(), #true())] =  [1]                                                                  
                                                                     [1]                                                                  
                                                                  >  [0]                                                                  
                                                                     [1]                                                                  
                                                                  =  [#true()]                                                            
                                                                                                                                          
                                [bfs^#(@queue, @futurequeue, @x)] =  [1 1] @futurequeue + [0 1] @queue + [0]                              
                                                                     [0 0]                [1 0]          [0]                              
                                                                  >= [1 1] @futurequeue + [0 1] @queue + [0]                              
                                                                     [0 0]                [0 0]          [0]                              
                                                                  =  [c_1(bfs#1^#(@queue, @futurequeue, @x))]                             
                                                                                                                                          
                         [bfs#1^#(::(@t, @ts), @futurequeue, @x)] =  [1 1] @futurequeue + [1 1] @t + [0 1] @ts + [0]                      
                                                                     [0 0]                [0 0]      [0 0]       [0]                      
                                                                  >= [1 1] @futurequeue + [1 1] @t + [0 1] @ts + [0]                      
                                                                     [0 0]                [0 0]      [0 0]       [0]                      
                                                                  =  [c_2(bfs#3^#(@t, @futurequeue, @ts, @x))]                            
                                                                                                                                          
                               [bfs#1^#(nil(), @futurequeue, @x)] =  [1 1] @futurequeue + [0]                                             
                                                                     [0 0]                [0]                                             
                                                                  >= [1 1] @futurequeue + [0]                                             
                                                                     [0 0]                [0]                                             
                                                                  =  [c_3(bfs#2^#(@futurequeue, @x))]                                     
                                                                                                                                          
                         [bfs#3^#(leaf(), @futurequeue, @ts, @x)] =  [1 1] @futurequeue + [0 1] @ts + [1]                                 
                                                                     [0 0]                [0 0]       [0]                                 
                                                                  >  [1 1] @futurequeue + [0 1] @ts + [0]                                 
                                                                     [0 0]                [0 0]       [0]                                 
                                                                  =  [c_4(bfs^#(@ts, @futurequeue, @x))]                                  
                                                                                                                                          
             [bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x)] =  [1 1] @futurequeue + [1 1] @t1 + [1 1] @t2 + [0 1] @ts + [1          
                                                                                                                               0] @y + [3]
                                                                     [0 0]                [0 0]       [0 0]       [0 0]       [0          
                                                                                                                               0]      [0]
                                                                  >= [1 1] @futurequeue + [1 1] @t1 + [1 1] @t2 + [0 1] @ts + [3]         
                                                                     [0 0]                [0 0]       [0 0]       [0 0]       [0]         
                                                                  =  [c_5(bfs#4^#(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y))]  
                                                                                                                                          
                                       [bfs#2^#(::(@t, @ts), @x)] =  [1 1] @t + [1 1] @ts + [1]                                           
                                                                     [0 0]      [0 0]       [0]                                           
                                                                  >  [1 1] @t + [0 1] @ts + [0]                                           
                                                                     [0 0]      [0 0]       [0]                                           
                                                                  =  [c_6(bfs^#(reverse(::(@t, @ts)), nil(), @x))]                        
                                                                                                                                          
         [bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y)] =  [1 1] @futurequeue + [1 1] @t1 + [1 1] @t2 + [0 1] @ts + [3]         
                                                                     [0 0]                [0 0]       [0 0]       [0 0]       [0]         
                                                                  >  [1 1] @futurequeue + [1 1] @t1 + [1 1] @t2 + [0 1] @ts + [2]         
                                                                     [0 0]                [0 0]       [0 0]       [0 0]       [0]         
                                                                  =  [c_7(bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x))]                
                                                                                                                                          
                                                 [bfs2^#(@t, @x)] =  [2 2] @t + [2 2] @x + [2]                                            
                                                                     [1 2]      [1 1]      [2]                                            
                                                                  >= [2 2] @t + [2 2] @x + [2]                                            
                                                                     [0 0]      [0 0]      [0]                                            
                                                                  =  [c_8(bfs2#1^#(dobfs(@t, @x), @x), dobfs^#(@t, @x))]                  
                                                                                                                                          
                                              [bfs2#1^#(@t', @x)] =  [1 1] @t' + [0 2] @x + [0]                                           
                                                                     [0 0]       [0 0]      [0]                                           
                                                                  >= [1 1] @t' + [0]                                                      
                                                                     [0 0]       [0]                                                      
                                                                  =  [c_9(dobfs^#(@t', @x))]                                              
                                                                                                                                          
                                                [dobfs^#(@t, @x)] =  [1 1] @t + [0 0] @x + [0]                                            
                                                                     [0 0]      [2 0]      [0]                                            
                                                                  >= [1 1] @t + [0]                                                       
                                                                     [0 0]      [0]                                                       
                                                                  =  [c_10(bfs^#(::(@t, nil()), nil(), @x))]                              
                                                                                                                                          
     
     Consider the set of all dependency pairs
     
     DPs:
       { 1: bfs^#(@queue, @futurequeue, @x) ->
            c_1(bfs#1^#(@queue, @futurequeue, @x))
       , 2: bfs#1^#(nil(), @futurequeue, @x) ->
            c_3(bfs#2^#(@futurequeue, @x))
       , 3: bfs#1^#(::(@t, @ts), @futurequeue, @x) ->
            c_2(bfs#3^#(@t, @futurequeue, @ts, @x))
       , 4: bfs#3^#(leaf(), @futurequeue, @ts, @x) ->
            c_4(bfs^#(@ts, @futurequeue, @x))
       , 5: bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
            c_5(bfs#4^#(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y))
       , 6: bfs#2^#(::(@t, @ts), @x) ->
            c_6(bfs^#(reverse(::(@t, @ts)), nil(), @x))
       , 7: bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
            c_7(bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x))
       , 8: bfs2^#(@t, @x) ->
            c_8(bfs2#1^#(dobfs(@t, @x), @x), dobfs^#(@t, @x))
       , 9: bfs2#1^#(@t', @x) -> c_9(dobfs^#(@t', @x))
       , 10: dobfs^#(@t, @x) -> c_10(bfs^#(::(@t, nil()), nil(), @x)) }
     
     Processor 'matrix interpretation of dimension 2' induces the
     complexity certificate YES(?,O(n^1)) on application of dependency
     pairs {4,6,7}. These cover all (indirect) predecessors of
     dependency pairs {1,2,3,4,5,6,7,8,9,10}, their number of
     application is equally bounded. The dependency pairs are shifted
     into the corresponding weak component(s).
     
     We apply the transformation 'removetails' on the sub-problem:
     
     Weak DPs:
       { bfs^#(@queue, @futurequeue, @x) ->
         c_1(bfs#1^#(@queue, @futurequeue, @x))
       , bfs#1^#(::(@t, @ts), @futurequeue, @x) ->
         c_2(bfs#3^#(@t, @futurequeue, @ts, @x))
       , bfs#1^#(nil(), @futurequeue, @x) ->
         c_3(bfs#2^#(@futurequeue, @x))
       , bfs#3^#(leaf(), @futurequeue, @ts, @x) ->
         c_4(bfs^#(@ts, @futurequeue, @x))
       , bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
         c_5(bfs#4^#(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y))
       , bfs#2^#(::(@t, @ts), @x) ->
         c_6(bfs^#(reverse(::(@t, @ts)), nil(), @x))
       , bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
         c_7(bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x))
       , bfs2^#(@t, @x) ->
         c_8(bfs2#1^#(dobfs(@t, @x), @x), dobfs^#(@t, @x))
       , bfs2#1^#(@t', @x) -> c_9(dobfs^#(@t', @x))
       , dobfs^#(@t, @x) -> c_10(bfs^#(::(@t, nil()), nil(), @x)) }
     Weak Trs:
       { #equal(@x, @y) -> #eq(@x, @y)
       , #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
         #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
       , #eq(::(@x_1, @x_2), nil()) -> #false()
       , #eq(::(@x_1, @x_2), leaf()) -> #false()
       , #eq(::(@x_1, @x_2), node(@y_1, @y_2, @y_3)) -> #false()
       , #eq(nil(), ::(@y_1, @y_2)) -> #false()
       , #eq(nil(), nil()) -> #true()
       , #eq(nil(), leaf()) -> #false()
       , #eq(nil(), node(@y_1, @y_2, @y_3)) -> #false()
       , #eq(leaf(), ::(@y_1, @y_2)) -> #false()
       , #eq(leaf(), nil()) -> #false()
       , #eq(leaf(), leaf()) -> #true()
       , #eq(leaf(), node(@y_1, @y_2, @y_3)) -> #false()
       , #eq(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2)) -> #false()
       , #eq(node(@x_1, @x_2, @x_3), nil()) -> #false()
       , #eq(node(@x_1, @x_2, @x_3), leaf()) -> #false()
       , #eq(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) ->
         #and(#eq(@x_1, @y_1), #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3)))
       , #eq(#0(), #0()) -> #true()
       , #eq(#0(), #neg(@y)) -> #false()
       , #eq(#0(), #pos(@y)) -> #false()
       , #eq(#0(), #s(@y)) -> #false()
       , #eq(#neg(@x), #0()) -> #false()
       , #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
       , #eq(#neg(@x), #pos(@y)) -> #false()
       , #eq(#pos(@x), #0()) -> #false()
       , #eq(#pos(@x), #neg(@y)) -> #false()
       , #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
       , #eq(#s(@x), #0()) -> #false()
       , #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
       , appendreverse(@toreverse, @sofar) ->
         appendreverse#1(@toreverse, @sofar)
       , appendreverse#1(::(@a, @as), @sofar) ->
         appendreverse(@as, ::(@a, @sofar))
       , appendreverse#1(nil(), @sofar) -> @sofar
       , bfs(@queue, @futurequeue, @x) -> bfs#1(@queue, @futurequeue, @x)
       , bfs#1(::(@t, @ts), @futurequeue, @x) ->
         bfs#3(@t, @futurequeue, @ts, @x)
       , bfs#1(nil(), @futurequeue, @x) -> bfs#2(@futurequeue, @x)
       , bfs#3(leaf(), @futurequeue, @ts, @x) ->
         bfs(@ts, @futurequeue, @x)
       , bfs#3(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
         bfs#4(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y)
       , bfs#2(::(@t, @ts), @x) -> bfs(reverse(::(@t, @ts)), nil(), @x)
       , bfs#2(nil(), @x) -> leaf()
       , reverse(@xs) -> appendreverse(@xs, nil())
       , bfs#4(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
         bfs(@ts, ::(@t2, ::(@t1, @futurequeue)), @x)
       , bfs#4(#true(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
         node(@y, @t1, @t2)
       , dobfs(@t, @x) -> bfs(::(@t, nil()), nil(), @x)
       , #and(#false(), #false()) -> #false()
       , #and(#false(), #true()) -> #false()
       , #and(#true(), #false()) -> #false()
       , #and(#true(), #true()) -> #true() }
     StartTerms: basic terms
     Strategy: innermost
     
     The following weak DPs constitute a sub-graph of the DG that is
     closed under successors. The DPs are removed.
     
     { bfs^#(@queue, @futurequeue, @x) ->
       c_1(bfs#1^#(@queue, @futurequeue, @x))
     , bfs#1^#(::(@t, @ts), @futurequeue, @x) ->
       c_2(bfs#3^#(@t, @futurequeue, @ts, @x))
     , bfs#1^#(nil(), @futurequeue, @x) ->
       c_3(bfs#2^#(@futurequeue, @x))
     , bfs#3^#(leaf(), @futurequeue, @ts, @x) ->
       c_4(bfs^#(@ts, @futurequeue, @x))
     , bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
       c_5(bfs#4^#(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y))
     , bfs#2^#(::(@t, @ts), @x) ->
       c_6(bfs^#(reverse(::(@t, @ts)), nil(), @x))
     , bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
       c_7(bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x))
     , bfs2^#(@t, @x) ->
       c_8(bfs2#1^#(dobfs(@t, @x), @x), dobfs^#(@t, @x))
     , bfs2#1^#(@t', @x) -> c_9(dobfs^#(@t', @x))
     , dobfs^#(@t, @x) -> c_10(bfs^#(::(@t, nil()), nil(), @x)) }
     
     
     We apply the transformation 'usablerules' on the sub-problem:
     
     Weak Trs:
       { #equal(@x, @y) -> #eq(@x, @y)
       , #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
         #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
       , #eq(::(@x_1, @x_2), nil()) -> #false()
       , #eq(::(@x_1, @x_2), leaf()) -> #false()
       , #eq(::(@x_1, @x_2), node(@y_1, @y_2, @y_3)) -> #false()
       , #eq(nil(), ::(@y_1, @y_2)) -> #false()
       , #eq(nil(), nil()) -> #true()
       , #eq(nil(), leaf()) -> #false()
       , #eq(nil(), node(@y_1, @y_2, @y_3)) -> #false()
       , #eq(leaf(), ::(@y_1, @y_2)) -> #false()
       , #eq(leaf(), nil()) -> #false()
       , #eq(leaf(), leaf()) -> #true()
       , #eq(leaf(), node(@y_1, @y_2, @y_3)) -> #false()
       , #eq(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2)) -> #false()
       , #eq(node(@x_1, @x_2, @x_3), nil()) -> #false()
       , #eq(node(@x_1, @x_2, @x_3), leaf()) -> #false()
       , #eq(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) ->
         #and(#eq(@x_1, @y_1), #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3)))
       , #eq(#0(), #0()) -> #true()
       , #eq(#0(), #neg(@y)) -> #false()
       , #eq(#0(), #pos(@y)) -> #false()
       , #eq(#0(), #s(@y)) -> #false()
       , #eq(#neg(@x), #0()) -> #false()
       , #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
       , #eq(#neg(@x), #pos(@y)) -> #false()
       , #eq(#pos(@x), #0()) -> #false()
       , #eq(#pos(@x), #neg(@y)) -> #false()
       , #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
       , #eq(#s(@x), #0()) -> #false()
       , #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
       , appendreverse(@toreverse, @sofar) ->
         appendreverse#1(@toreverse, @sofar)
       , appendreverse#1(::(@a, @as), @sofar) ->
         appendreverse(@as, ::(@a, @sofar))
       , appendreverse#1(nil(), @sofar) -> @sofar
       , bfs(@queue, @futurequeue, @x) -> bfs#1(@queue, @futurequeue, @x)
       , bfs#1(::(@t, @ts), @futurequeue, @x) ->
         bfs#3(@t, @futurequeue, @ts, @x)
       , bfs#1(nil(), @futurequeue, @x) -> bfs#2(@futurequeue, @x)
       , bfs#3(leaf(), @futurequeue, @ts, @x) ->
         bfs(@ts, @futurequeue, @x)
       , bfs#3(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
         bfs#4(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y)
       , bfs#2(::(@t, @ts), @x) -> bfs(reverse(::(@t, @ts)), nil(), @x)
       , bfs#2(nil(), @x) -> leaf()
       , reverse(@xs) -> appendreverse(@xs, nil())
       , bfs#4(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
         bfs(@ts, ::(@t2, ::(@t1, @futurequeue)), @x)
       , bfs#4(#true(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
         node(@y, @t1, @t2)
       , dobfs(@t, @x) -> bfs(::(@t, nil()), nil(), @x)
       , #and(#false(), #false()) -> #false()
       , #and(#false(), #true()) -> #false()
       , #and(#true(), #false()) -> #false()
       , #and(#true(), #true()) -> #true() }
     StartTerms: basic terms
     Strategy: innermost
     
     No rule is usable, rules are removed from the input problem.
     
     
     We are left with following problem, upon which TcT provides the
     certificate YES(O(1),O(1)).
     
     Rules: Empty
     Obligation:
       innermost runtime complexity
     Answer:
       YES(O(1),O(1))
     
     Empty rules are trivially bounded
   
   We return to the main proof.
   
   We are left with following problem, upon which TcT provides the
   certificate YES(O(1),O(n^1)).
   
   Strict DPs:
     { appendreverse^#(@toreverse, @sofar) ->
       c_1(appendreverse#1^#(@toreverse, @sofar))
     , appendreverse#1^#(::(@a, @as), @sofar) ->
       c_2(appendreverse^#(@as, ::(@a, @sofar)))
     , reverse^#(@xs) -> c_10(appendreverse^#(@xs, nil())) }
   Weak DPs:
     { bfs^#(@queue, @futurequeue, @x) ->
       bfs#1^#(@queue, @futurequeue, @x)
     , bfs#1^#(::(@t, @ts), @futurequeue, @x) ->
       bfs#3^#(@t, @futurequeue, @ts, @x)
     , bfs#1^#(nil(), @futurequeue, @x) -> bfs#2^#(@futurequeue, @x)
     , bfs#3^#(leaf(), @futurequeue, @ts, @x) ->
       bfs^#(@ts, @futurequeue, @x)
     , bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
       bfs#4^#(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y)
     , bfs#2^#(::(@t, @ts), @x) ->
       bfs^#(reverse(::(@t, @ts)), nil(), @x)
     , bfs#2^#(::(@t, @ts), @x) -> reverse^#(::(@t, @ts))
     , bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
       bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x)
     , bfs2^#(@t, @x) -> bfs2#1^#(dobfs(@t, @x), @x)
     , bfs2^#(@t, @x) -> dobfs^#(@t, @x)
     , bfs2#1^#(@t', @x) -> dobfs^#(@t', @x)
     , dobfs^#(@t, @x) -> bfs^#(::(@t, nil()), nil(), @x) }
   Weak Trs:
     { #equal(@x, @y) -> #eq(@x, @y)
     , #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
       #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
     , #eq(::(@x_1, @x_2), nil()) -> #false()
     , #eq(::(@x_1, @x_2), leaf()) -> #false()
     , #eq(::(@x_1, @x_2), node(@y_1, @y_2, @y_3)) -> #false()
     , #eq(nil(), ::(@y_1, @y_2)) -> #false()
     , #eq(nil(), nil()) -> #true()
     , #eq(nil(), leaf()) -> #false()
     , #eq(nil(), node(@y_1, @y_2, @y_3)) -> #false()
     , #eq(leaf(), ::(@y_1, @y_2)) -> #false()
     , #eq(leaf(), nil()) -> #false()
     , #eq(leaf(), leaf()) -> #true()
     , #eq(leaf(), node(@y_1, @y_2, @y_3)) -> #false()
     , #eq(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2)) -> #false()
     , #eq(node(@x_1, @x_2, @x_3), nil()) -> #false()
     , #eq(node(@x_1, @x_2, @x_3), leaf()) -> #false()
     , #eq(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) ->
       #and(#eq(@x_1, @y_1), #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3)))
     , #eq(#0(), #0()) -> #true()
     , #eq(#0(), #neg(@y)) -> #false()
     , #eq(#0(), #pos(@y)) -> #false()
     , #eq(#0(), #s(@y)) -> #false()
     , #eq(#neg(@x), #0()) -> #false()
     , #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
     , #eq(#neg(@x), #pos(@y)) -> #false()
     , #eq(#pos(@x), #0()) -> #false()
     , #eq(#pos(@x), #neg(@y)) -> #false()
     , #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
     , #eq(#s(@x), #0()) -> #false()
     , #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
     , appendreverse(@toreverse, @sofar) ->
       appendreverse#1(@toreverse, @sofar)
     , appendreverse#1(::(@a, @as), @sofar) ->
       appendreverse(@as, ::(@a, @sofar))
     , appendreverse#1(nil(), @sofar) -> @sofar
     , bfs(@queue, @futurequeue, @x) -> bfs#1(@queue, @futurequeue, @x)
     , bfs#1(::(@t, @ts), @futurequeue, @x) ->
       bfs#3(@t, @futurequeue, @ts, @x)
     , bfs#1(nil(), @futurequeue, @x) -> bfs#2(@futurequeue, @x)
     , bfs#3(leaf(), @futurequeue, @ts, @x) ->
       bfs(@ts, @futurequeue, @x)
     , bfs#3(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
       bfs#4(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y)
     , bfs#2(::(@t, @ts), @x) -> bfs(reverse(::(@t, @ts)), nil(), @x)
     , bfs#2(nil(), @x) -> leaf()
     , reverse(@xs) -> appendreverse(@xs, nil())
     , bfs#4(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
       bfs(@ts, ::(@t2, ::(@t1, @futurequeue)), @x)
     , bfs#4(#true(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
       node(@y, @t1, @t2)
     , dobfs(@t, @x) -> bfs(::(@t, nil()), nil(), @x)
     , #and(#false(), #false()) -> #false()
     , #and(#false(), #true()) -> #false()
     , #and(#true(), #false()) -> #false()
     , #and(#true(), #true()) -> #true() }
   Obligation:
     innermost runtime complexity
   Answer:
     YES(O(1),O(n^1))
   
   Consider the dependency graph
   
     1: appendreverse^#(@toreverse, @sofar) ->
        c_1(appendreverse#1^#(@toreverse, @sofar))
        -->_1 appendreverse#1^#(::(@a, @as), @sofar) ->
              c_2(appendreverse^#(@as, ::(@a, @sofar))) :2
     
     2: appendreverse#1^#(::(@a, @as), @sofar) ->
        c_2(appendreverse^#(@as, ::(@a, @sofar)))
        -->_1 appendreverse^#(@toreverse, @sofar) ->
              c_1(appendreverse#1^#(@toreverse, @sofar)) :1
     
     3: reverse^#(@xs) -> c_10(appendreverse^#(@xs, nil()))
        -->_1 appendreverse^#(@toreverse, @sofar) ->
              c_1(appendreverse#1^#(@toreverse, @sofar)) :1
     
     4: bfs^#(@queue, @futurequeue, @x) ->
        bfs#1^#(@queue, @futurequeue, @x)
        -->_1 bfs#1^#(nil(), @futurequeue, @x) ->
              bfs#2^#(@futurequeue, @x) :6
        -->_1 bfs#1^#(::(@t, @ts), @futurequeue, @x) ->
              bfs#3^#(@t, @futurequeue, @ts, @x) :5
     
     5: bfs#1^#(::(@t, @ts), @futurequeue, @x) ->
        bfs#3^#(@t, @futurequeue, @ts, @x)
        -->_1 bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
              bfs#4^#(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y) :8
        -->_1 bfs#3^#(leaf(), @futurequeue, @ts, @x) ->
              bfs^#(@ts, @futurequeue, @x) :7
     
     6: bfs#1^#(nil(), @futurequeue, @x) -> bfs#2^#(@futurequeue, @x)
        -->_1 bfs#2^#(::(@t, @ts), @x) -> reverse^#(::(@t, @ts)) :10
        -->_1 bfs#2^#(::(@t, @ts), @x) ->
              bfs^#(reverse(::(@t, @ts)), nil(), @x) :9
     
     7: bfs#3^#(leaf(), @futurequeue, @ts, @x) ->
        bfs^#(@ts, @futurequeue, @x)
        -->_1 bfs^#(@queue, @futurequeue, @x) ->
              bfs#1^#(@queue, @futurequeue, @x) :4
     
     8: bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
        bfs#4^#(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y)
        -->_1 bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
              bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x) :11
     
     9: bfs#2^#(::(@t, @ts), @x) ->
        bfs^#(reverse(::(@t, @ts)), nil(), @x)
        -->_1 bfs^#(@queue, @futurequeue, @x) ->
              bfs#1^#(@queue, @futurequeue, @x) :4
     
     10: bfs#2^#(::(@t, @ts), @x) -> reverse^#(::(@t, @ts))
        -->_1 reverse^#(@xs) -> c_10(appendreverse^#(@xs, nil())) :3
     
     11: bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
         bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x)
        -->_1 bfs^#(@queue, @futurequeue, @x) ->
              bfs#1^#(@queue, @futurequeue, @x) :4
     
     12: bfs2^#(@t, @x) -> bfs2#1^#(dobfs(@t, @x), @x)
        -->_1 bfs2#1^#(@t', @x) -> dobfs^#(@t', @x) :14
     
     13: bfs2^#(@t, @x) -> dobfs^#(@t, @x)
        -->_1 dobfs^#(@t, @x) -> bfs^#(::(@t, nil()), nil(), @x) :15
     
     14: bfs2#1^#(@t', @x) -> dobfs^#(@t', @x)
        -->_1 dobfs^#(@t, @x) -> bfs^#(::(@t, nil()), nil(), @x) :15
     
     15: dobfs^#(@t, @x) -> bfs^#(::(@t, nil()), nil(), @x)
        -->_1 bfs^#(@queue, @futurequeue, @x) ->
              bfs#1^#(@queue, @futurequeue, @x) :4
     
   
   Following roots of the dependency graph are removed, as the
   considered set of starting terms is closed under reduction with
   respect to these rules (modulo compound contexts).
   
     { bfs2^#(@t, @x) -> dobfs^#(@t, @x) }
   
   
   We are left with following problem, upon which TcT provides the
   certificate YES(O(1),O(n^1)).
   
   Strict DPs:
     { appendreverse^#(@toreverse, @sofar) ->
       c_1(appendreverse#1^#(@toreverse, @sofar))
     , appendreverse#1^#(::(@a, @as), @sofar) ->
       c_2(appendreverse^#(@as, ::(@a, @sofar)))
     , reverse^#(@xs) -> c_10(appendreverse^#(@xs, nil())) }
   Weak DPs:
     { bfs^#(@queue, @futurequeue, @x) ->
       bfs#1^#(@queue, @futurequeue, @x)
     , bfs#1^#(::(@t, @ts), @futurequeue, @x) ->
       bfs#3^#(@t, @futurequeue, @ts, @x)
     , bfs#1^#(nil(), @futurequeue, @x) -> bfs#2^#(@futurequeue, @x)
     , bfs#3^#(leaf(), @futurequeue, @ts, @x) ->
       bfs^#(@ts, @futurequeue, @x)
     , bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
       bfs#4^#(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y)
     , bfs#2^#(::(@t, @ts), @x) ->
       bfs^#(reverse(::(@t, @ts)), nil(), @x)
     , bfs#2^#(::(@t, @ts), @x) -> reverse^#(::(@t, @ts))
     , bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
       bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x)
     , bfs2^#(@t, @x) -> bfs2#1^#(dobfs(@t, @x), @x)
     , bfs2#1^#(@t', @x) -> dobfs^#(@t', @x)
     , dobfs^#(@t, @x) -> bfs^#(::(@t, nil()), nil(), @x) }
   Weak Trs:
     { #equal(@x, @y) -> #eq(@x, @y)
     , #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
       #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
     , #eq(::(@x_1, @x_2), nil()) -> #false()
     , #eq(::(@x_1, @x_2), leaf()) -> #false()
     , #eq(::(@x_1, @x_2), node(@y_1, @y_2, @y_3)) -> #false()
     , #eq(nil(), ::(@y_1, @y_2)) -> #false()
     , #eq(nil(), nil()) -> #true()
     , #eq(nil(), leaf()) -> #false()
     , #eq(nil(), node(@y_1, @y_2, @y_3)) -> #false()
     , #eq(leaf(), ::(@y_1, @y_2)) -> #false()
     , #eq(leaf(), nil()) -> #false()
     , #eq(leaf(), leaf()) -> #true()
     , #eq(leaf(), node(@y_1, @y_2, @y_3)) -> #false()
     , #eq(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2)) -> #false()
     , #eq(node(@x_1, @x_2, @x_3), nil()) -> #false()
     , #eq(node(@x_1, @x_2, @x_3), leaf()) -> #false()
     , #eq(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) ->
       #and(#eq(@x_1, @y_1), #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3)))
     , #eq(#0(), #0()) -> #true()
     , #eq(#0(), #neg(@y)) -> #false()
     , #eq(#0(), #pos(@y)) -> #false()
     , #eq(#0(), #s(@y)) -> #false()
     , #eq(#neg(@x), #0()) -> #false()
     , #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
     , #eq(#neg(@x), #pos(@y)) -> #false()
     , #eq(#pos(@x), #0()) -> #false()
     , #eq(#pos(@x), #neg(@y)) -> #false()
     , #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
     , #eq(#s(@x), #0()) -> #false()
     , #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
     , appendreverse(@toreverse, @sofar) ->
       appendreverse#1(@toreverse, @sofar)
     , appendreverse#1(::(@a, @as), @sofar) ->
       appendreverse(@as, ::(@a, @sofar))
     , appendreverse#1(nil(), @sofar) -> @sofar
     , bfs(@queue, @futurequeue, @x) -> bfs#1(@queue, @futurequeue, @x)
     , bfs#1(::(@t, @ts), @futurequeue, @x) ->
       bfs#3(@t, @futurequeue, @ts, @x)
     , bfs#1(nil(), @futurequeue, @x) -> bfs#2(@futurequeue, @x)
     , bfs#3(leaf(), @futurequeue, @ts, @x) ->
       bfs(@ts, @futurequeue, @x)
     , bfs#3(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
       bfs#4(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y)
     , bfs#2(::(@t, @ts), @x) -> bfs(reverse(::(@t, @ts)), nil(), @x)
     , bfs#2(nil(), @x) -> leaf()
     , reverse(@xs) -> appendreverse(@xs, nil())
     , bfs#4(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
       bfs(@ts, ::(@t2, ::(@t1, @futurequeue)), @x)
     , bfs#4(#true(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
       node(@y, @t1, @t2)
     , dobfs(@t, @x) -> bfs(::(@t, nil()), nil(), @x)
     , #and(#false(), #false()) -> #false()
     , #and(#false(), #true()) -> #false()
     , #and(#true(), #false()) -> #false()
     , #and(#true(), #true()) -> #true() }
   Obligation:
     innermost runtime complexity
   Answer:
     YES(O(1),O(n^1))
   
   We use the processor 'matrix interpretation of dimension 1' to
   orient following rules strictly.
   
   DPs:
     { 2: appendreverse#1^#(::(@a, @as), @sofar) ->
          c_2(appendreverse^#(@as, ::(@a, @sofar)))
     , 7: bfs#3^#(leaf(), @futurequeue, @ts, @x) ->
          bfs^#(@ts, @futurequeue, @x) }
   Trs:
     { bfs#3(leaf(), @futurequeue, @ts, @x) ->
       bfs(@ts, @futurequeue, @x)
     , bfs#4(#true(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
       node(@y, @t1, @t2) }
   
   Sub-proof:
   ----------
     The following argument positions are usable:
       Uargs(c_1) = {1}, Uargs(c_2) = {1}, Uargs(c_10) = {1}
     
     TcT has computed following constructor-based matrix interpretation
     satisfying not(EDA).
     
                            [#equal](x1, x2) = [0]
                                                  
                               [#eq](x1, x2) = [0]
                                                  
                     [appendreverse](x1, x2) = [1] x1 + [1] x2 + [0]
                                                                    
                   [appendreverse#1](x1, x2) = [1] x1 + [1] x2 + [0]
                                                                    
                                [::](x1, x2) = [1] x1 + [1] x2 + [1]
                                                                    
                                       [nil] = [0]
                                                  
                           [bfs](x1, x2, x3) = [1] x1 + [1] x2 + [0]
                                                                    
                         [bfs#1](x1, x2, x3) = [1] x1 + [1] x2 + [0]
                                                                    
                     [bfs#3](x1, x2, x3, x4) = [1] x1 + [1] x2 + [1] x3 + [1]
                                                                             
                             [bfs#2](x1, x2) = [1] x1 + [0]
                                                           
                               [reverse](x1) = [1] x1 + [0]
                                                           
                                      [leaf] = [0]
                                                  
                          [node](x1, x2, x3) = [1] x2 + [1] x3 + [1]
                                                                    
         [bfs#4](x1, x2, x3, x4, x5, x6, x7) = [1] x2 + [1] x3 + [1] x4 + [1] x5 + [2]
                                                                                      
                                    [#false] = [0]
                                                  
                                     [#true] = [0]
                                                  
                             [dobfs](x1, x2) = [1] x1 + [1]
                                                           
                              [#and](x1, x2) = [0]
                                                  
                                        [#0] = [0]
                                                  
                                  [#neg](x1) = [1] x1 + [0]
                                                           
                                  [#pos](x1) = [1] x1 + [0]
                                                           
                                    [#s](x1) = [1] x1 + [0]
                                                           
                          [#equal^#](x1, x2) = [0]
                                                  
                             [#eq^#](x1, x2) = [0]
                                                  
                   [appendreverse^#](x1, x2) = [1] x1 + [0]
                                                           
                 [appendreverse#1^#](x1, x2) = [1] x1 + [0]
                                                           
                         [bfs^#](x1, x2, x3) = [1] x1 + [1] x2 + [0]
                                                                    
                       [bfs#1^#](x1, x2, x3) = [1] x1 + [1] x2 + [0]
                                                                    
                   [bfs#3^#](x1, x2, x3, x4) = [1] x1 + [1] x2 + [1] x3 + [1]
                                                                             
                           [bfs#2^#](x1, x2) = [1] x1 + [0]
                                                           
       [bfs#4^#](x1, x2, x3, x4, x5, x6, x7) = [1] x2 + [1] x3 + [1] x4 + [1] x5 + [2]
                                                                                      
                             [reverse^#](x1) = [1] x1 + [0]
                                                           
                            [bfs2^#](x1, x2) = [2] x1 + [2] x2 + [2]
                                                                    
                          [bfs2#1^#](x1, x2) = [1] x1 + [1]
                                                           
                           [dobfs^#](x1, x2) = [1] x1 + [1]
                                                           
                             [dfs^#](x1, x2) = [0]
                                                  
                           [dfs#1^#](x1, x2) = [0]
                                                  
                   [dfs#2^#](x1, x2, x3, x4) = [0]
                                                  
           [dfs#3^#](x1, x2, x3, x4, x5, x6) = [0]
                                                  
                           [dodfs^#](x1, x2) = [0]
                                                  
                            [#and^#](x1, x2) = [0]
                                                  
                                   [c_1](x1) = [1] x1 + [0]
                                                           
                                   [c_2](x1) = [1] x1 + [0]
                                                           
                                  [c_10](x1) = [1] x1 + [0]
     
     This order satisfies following ordering constraints
     
                            [appendreverse(@toreverse, @sofar)] =  [1] @sofar + [1] @toreverse + [0]                             
                                                                >= [1] @sofar + [1] @toreverse + [0]                             
                                                                =  [appendreverse#1(@toreverse, @sofar)]                         
                                                                                                                                 
                         [appendreverse#1(::(@a, @as), @sofar)] =  [1] @a + [1] @as + [1] @sofar + [1]                           
                                                                >= [1] @a + [1] @as + [1] @sofar + [1]                           
                                                                =  [appendreverse(@as, ::(@a, @sofar))]                          
                                                                                                                                 
                               [appendreverse#1(nil(), @sofar)] =  [1] @sofar + [0]                                              
                                                                >= [1] @sofar + [0]                                              
                                                                =  [@sofar]                                                      
                                                                                                                                 
                                [bfs(@queue, @futurequeue, @x)] =  [1] @futurequeue + [1] @queue + [0]                           
                                                                >= [1] @futurequeue + [1] @queue + [0]                           
                                                                =  [bfs#1(@queue, @futurequeue, @x)]                             
                                                                                                                                 
                         [bfs#1(::(@t, @ts), @futurequeue, @x)] =  [1] @futurequeue + [1] @t + [1] @ts + [1]                     
                                                                >= [1] @futurequeue + [1] @t + [1] @ts + [1]                     
                                                                =  [bfs#3(@t, @futurequeue, @ts, @x)]                            
                                                                                                                                 
                               [bfs#1(nil(), @futurequeue, @x)] =  [1] @futurequeue + [0]                                        
                                                                >= [1] @futurequeue + [0]                                        
                                                                =  [bfs#2(@futurequeue, @x)]                                     
                                                                                                                                 
                         [bfs#3(leaf(), @futurequeue, @ts, @x)] =  [1] @futurequeue + [1] @ts + [1]                              
                                                                >  [1] @futurequeue + [1] @ts + [0]                              
                                                                =  [bfs(@ts, @futurequeue, @x)]                                  
                                                                                                                                 
             [bfs#3(node(@y, @t1, @t2), @futurequeue, @ts, @x)] =  [1] @futurequeue + [1] @t1 + [1] @t2 + [1] @ts + [2]          
                                                                >= [1] @futurequeue + [1] @t1 + [1] @t2 + [1] @ts + [2]          
                                                                =  [bfs#4(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y)]  
                                                                                                                                 
                                       [bfs#2(::(@t, @ts), @x)] =  [1] @t + [1] @ts + [1]                                        
                                                                >= [1] @t + [1] @ts + [1]                                        
                                                                =  [bfs(reverse(::(@t, @ts)), nil(), @x)]                        
                                                                                                                                 
                                             [bfs#2(nil(), @x)] =  [0]                                                           
                                                                >= [0]                                                           
                                                                =  [leaf()]                                                      
                                                                                                                                 
                                                 [reverse(@xs)] =  [1] @xs + [0]                                                 
                                                                >= [1] @xs + [0]                                                 
                                                                =  [appendreverse(@xs, nil())]                                   
                                                                                                                                 
         [bfs#4(#false(), @futurequeue, @t1, @t2, @ts, @x, @y)] =  [1] @futurequeue + [1] @t1 + [1] @t2 + [1] @ts + [2]          
                                                                >= [1] @futurequeue + [1] @t1 + [1] @t2 + [1] @ts + [2]          
                                                                =  [bfs(@ts, ::(@t2, ::(@t1, @futurequeue)), @x)]                
                                                                                                                                 
          [bfs#4(#true(), @futurequeue, @t1, @t2, @ts, @x, @y)] =  [1] @futurequeue + [1] @t1 + [1] @t2 + [1] @ts + [2]          
                                                                >  [1] @t1 + [1] @t2 + [1]                                       
                                                                =  [node(@y, @t1, @t2)]                                          
                                                                                                                                 
                                                [dobfs(@t, @x)] =  [1] @t + [1]                                                  
                                                                >= [1] @t + [1]                                                  
                                                                =  [bfs(::(@t, nil()), nil(), @x)]                               
                                                                                                                                 
                          [appendreverse^#(@toreverse, @sofar)] =  [1] @toreverse + [0]                                          
                                                                >= [1] @toreverse + [0]                                          
                                                                =  [c_1(appendreverse#1^#(@toreverse, @sofar))]                  
                                                                                                                                 
                       [appendreverse#1^#(::(@a, @as), @sofar)] =  [1] @a + [1] @as + [1]                                        
                                                                >  [1] @as + [0]                                                 
                                                                =  [c_2(appendreverse^#(@as, ::(@a, @sofar)))]                   
                                                                                                                                 
                              [bfs^#(@queue, @futurequeue, @x)] =  [1] @futurequeue + [1] @queue + [0]                           
                                                                >= [1] @futurequeue + [1] @queue + [0]                           
                                                                =  [bfs#1^#(@queue, @futurequeue, @x)]                           
                                                                                                                                 
                       [bfs#1^#(::(@t, @ts), @futurequeue, @x)] =  [1] @futurequeue + [1] @t + [1] @ts + [1]                     
                                                                >= [1] @futurequeue + [1] @t + [1] @ts + [1]                     
                                                                =  [bfs#3^#(@t, @futurequeue, @ts, @x)]                          
                                                                                                                                 
                             [bfs#1^#(nil(), @futurequeue, @x)] =  [1] @futurequeue + [0]                                        
                                                                >= [1] @futurequeue + [0]                                        
                                                                =  [bfs#2^#(@futurequeue, @x)]                                   
                                                                                                                                 
                       [bfs#3^#(leaf(), @futurequeue, @ts, @x)] =  [1] @futurequeue + [1] @ts + [1]                              
                                                                >  [1] @futurequeue + [1] @ts + [0]                              
                                                                =  [bfs^#(@ts, @futurequeue, @x)]                                
                                                                                                                                 
           [bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x)] =  [1] @futurequeue + [1] @t1 + [1] @t2 + [1] @ts + [2]          
                                                                >= [1] @futurequeue + [1] @t1 + [1] @t2 + [1] @ts + [2]          
                                                                =  [bfs#4^#(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y)]
                                                                                                                                 
                                     [bfs#2^#(::(@t, @ts), @x)] =  [1] @t + [1] @ts + [1]                                        
                                                                >= [1] @t + [1] @ts + [1]                                        
                                                                =  [bfs^#(reverse(::(@t, @ts)), nil(), @x)]                      
                                                                                                                                 
                                     [bfs#2^#(::(@t, @ts), @x)] =  [1] @t + [1] @ts + [1]                                        
                                                                >= [1] @t + [1] @ts + [1]                                        
                                                                =  [reverse^#(::(@t, @ts))]                                      
                                                                                                                                 
       [bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y)] =  [1] @futurequeue + [1] @t1 + [1] @t2 + [1] @ts + [2]          
                                                                >= [1] @futurequeue + [1] @t1 + [1] @t2 + [1] @ts + [2]          
                                                                =  [bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x)]              
                                                                                                                                 
                                               [reverse^#(@xs)] =  [1] @xs + [0]                                                 
                                                                >= [1] @xs + [0]                                                 
                                                                =  [c_10(appendreverse^#(@xs, nil()))]                           
                                                                                                                                 
                                               [bfs2^#(@t, @x)] =  [2] @t + [2] @x + [2]                                         
                                                                >= [1] @t + [2]                                                  
                                                                =  [bfs2#1^#(dobfs(@t, @x), @x)]                                 
                                                                                                                                 
                                            [bfs2#1^#(@t', @x)] =  [1] @t' + [1]                                                 
                                                                >= [1] @t' + [1]                                                 
                                                                =  [dobfs^#(@t', @x)]                                            
                                                                                                                                 
                                              [dobfs^#(@t, @x)] =  [1] @t + [1]                                                  
                                                                >= [1] @t + [1]                                                  
                                                                =  [bfs^#(::(@t, nil()), nil(), @x)]                             
                                                                                                                                 
   
   Consider the set of all dependency pairs
   
   DPs:
     { 1: appendreverse^#(@toreverse, @sofar) ->
          c_1(appendreverse#1^#(@toreverse, @sofar))
     , 2: appendreverse#1^#(::(@a, @as), @sofar) ->
          c_2(appendreverse^#(@as, ::(@a, @sofar)))
     , 3: reverse^#(@xs) -> c_10(appendreverse^#(@xs, nil()))
     , 4: bfs^#(@queue, @futurequeue, @x) ->
          bfs#1^#(@queue, @futurequeue, @x)
     , 5: bfs#1^#(::(@t, @ts), @futurequeue, @x) ->
          bfs#3^#(@t, @futurequeue, @ts, @x)
     , 6: bfs#1^#(nil(), @futurequeue, @x) -> bfs#2^#(@futurequeue, @x)
     , 7: bfs#3^#(leaf(), @futurequeue, @ts, @x) ->
          bfs^#(@ts, @futurequeue, @x)
     , 8: bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
          bfs#4^#(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y)
     , 9: bfs#2^#(::(@t, @ts), @x) ->
          bfs^#(reverse(::(@t, @ts)), nil(), @x)
     , 10: bfs#2^#(::(@t, @ts), @x) -> reverse^#(::(@t, @ts))
     , 11: bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
           bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x)
     , 12: bfs2^#(@t, @x) -> bfs2#1^#(dobfs(@t, @x), @x)
     , 13: bfs2#1^#(@t', @x) -> dobfs^#(@t', @x)
     , 14: dobfs^#(@t, @x) -> bfs^#(::(@t, nil()), nil(), @x) }
   
   Processor 'matrix interpretation of dimension 1' induces the
   complexity certificate YES(?,O(n^1)) on application of dependency
   pairs {2,7}. These cover all (indirect) predecessors of dependency
   pairs {2,7,12,13,14}, their number of application is equally
   bounded. The dependency pairs are shifted into the corresponding
   weak component(s).
   
   
   We are left with following problem, upon which TcT provides the
   certificate YES(O(1),O(n^1)).
   
   Strict DPs:
     { appendreverse^#(@toreverse, @sofar) ->
       c_1(appendreverse#1^#(@toreverse, @sofar))
     , reverse^#(@xs) -> c_10(appendreverse^#(@xs, nil())) }
   Weak DPs:
     { appendreverse#1^#(::(@a, @as), @sofar) ->
       c_2(appendreverse^#(@as, ::(@a, @sofar)))
     , bfs^#(@queue, @futurequeue, @x) ->
       bfs#1^#(@queue, @futurequeue, @x)
     , bfs#1^#(::(@t, @ts), @futurequeue, @x) ->
       bfs#3^#(@t, @futurequeue, @ts, @x)
     , bfs#1^#(nil(), @futurequeue, @x) -> bfs#2^#(@futurequeue, @x)
     , bfs#3^#(leaf(), @futurequeue, @ts, @x) ->
       bfs^#(@ts, @futurequeue, @x)
     , bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
       bfs#4^#(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y)
     , bfs#2^#(::(@t, @ts), @x) ->
       bfs^#(reverse(::(@t, @ts)), nil(), @x)
     , bfs#2^#(::(@t, @ts), @x) -> reverse^#(::(@t, @ts))
     , bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
       bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x)
     , bfs2^#(@t, @x) -> bfs2#1^#(dobfs(@t, @x), @x)
     , bfs2#1^#(@t', @x) -> dobfs^#(@t', @x)
     , dobfs^#(@t, @x) -> bfs^#(::(@t, nil()), nil(), @x) }
   Weak Trs:
     { #equal(@x, @y) -> #eq(@x, @y)
     , #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
       #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
     , #eq(::(@x_1, @x_2), nil()) -> #false()
     , #eq(::(@x_1, @x_2), leaf()) -> #false()
     , #eq(::(@x_1, @x_2), node(@y_1, @y_2, @y_3)) -> #false()
     , #eq(nil(), ::(@y_1, @y_2)) -> #false()
     , #eq(nil(), nil()) -> #true()
     , #eq(nil(), leaf()) -> #false()
     , #eq(nil(), node(@y_1, @y_2, @y_3)) -> #false()
     , #eq(leaf(), ::(@y_1, @y_2)) -> #false()
     , #eq(leaf(), nil()) -> #false()
     , #eq(leaf(), leaf()) -> #true()
     , #eq(leaf(), node(@y_1, @y_2, @y_3)) -> #false()
     , #eq(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2)) -> #false()
     , #eq(node(@x_1, @x_2, @x_3), nil()) -> #false()
     , #eq(node(@x_1, @x_2, @x_3), leaf()) -> #false()
     , #eq(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) ->
       #and(#eq(@x_1, @y_1), #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3)))
     , #eq(#0(), #0()) -> #true()
     , #eq(#0(), #neg(@y)) -> #false()
     , #eq(#0(), #pos(@y)) -> #false()
     , #eq(#0(), #s(@y)) -> #false()
     , #eq(#neg(@x), #0()) -> #false()
     , #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
     , #eq(#neg(@x), #pos(@y)) -> #false()
     , #eq(#pos(@x), #0()) -> #false()
     , #eq(#pos(@x), #neg(@y)) -> #false()
     , #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
     , #eq(#s(@x), #0()) -> #false()
     , #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
     , appendreverse(@toreverse, @sofar) ->
       appendreverse#1(@toreverse, @sofar)
     , appendreverse#1(::(@a, @as), @sofar) ->
       appendreverse(@as, ::(@a, @sofar))
     , appendreverse#1(nil(), @sofar) -> @sofar
     , bfs(@queue, @futurequeue, @x) -> bfs#1(@queue, @futurequeue, @x)
     , bfs#1(::(@t, @ts), @futurequeue, @x) ->
       bfs#3(@t, @futurequeue, @ts, @x)
     , bfs#1(nil(), @futurequeue, @x) -> bfs#2(@futurequeue, @x)
     , bfs#3(leaf(), @futurequeue, @ts, @x) ->
       bfs(@ts, @futurequeue, @x)
     , bfs#3(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
       bfs#4(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y)
     , bfs#2(::(@t, @ts), @x) -> bfs(reverse(::(@t, @ts)), nil(), @x)
     , bfs#2(nil(), @x) -> leaf()
     , reverse(@xs) -> appendreverse(@xs, nil())
     , bfs#4(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
       bfs(@ts, ::(@t2, ::(@t1, @futurequeue)), @x)
     , bfs#4(#true(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
       node(@y, @t1, @t2)
     , dobfs(@t, @x) -> bfs(::(@t, nil()), nil(), @x)
     , #and(#false(), #false()) -> #false()
     , #and(#false(), #true()) -> #false()
     , #and(#true(), #false()) -> #false()
     , #and(#true(), #true()) -> #true() }
   Obligation:
     innermost runtime complexity
   Answer:
     YES(O(1),O(n^1))
   
   We use the processor 'matrix interpretation of dimension 2' to
   orient following rules strictly.
   
   DPs:
     { 3: appendreverse#1^#(::(@a, @as), @sofar) ->
          c_2(appendreverse^#(@as, ::(@a, @sofar)))
     , 6: bfs#1^#(nil(), @futurequeue, @x) ->
          bfs#2^#(@futurequeue, @x) }
   Trs:
     { appendreverse#1(nil(), @sofar) -> @sofar
     , bfs#2(nil(), @x) -> leaf()
     , bfs#4(#true(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
       node(@y, @t1, @t2) }
   
   Sub-proof:
   ----------
     The following argument positions are usable:
       Uargs(c_1) = {1}, Uargs(c_2) = {1}, Uargs(c_10) = {1}
     
     TcT has computed following constructor-based matrix interpretation
     satisfying not(EDA) and not(IDA(1)).
     
                            [#equal](x1, x2) = [0 0] x2 + [0]
                                               [1 0]      [1]
                                                             
                               [#eq](x1, x2) = [0 0] x2 + [0]
                                               [1 0]      [1]
                                                             
                     [appendreverse](x1, x2) = [1 0] x1 + [1 0] x2 + [0]
                                               [0 1]      [0 1]      [0]
                                                                        
                   [appendreverse#1](x1, x2) = [1 0] x1 + [1 0] x2 + [0]
                                               [0 1]      [0 1]      [0]
                                                                        
                                [::](x1, x2) = [0 0] x1 + [1 0] x2 + [2]
                                               [0 1]      [0 1]      [0]
                                                                        
                                       [nil] = [1]
                                               [0]
                                                  
                           [bfs](x1, x2, x3) = [0 0] x1 + [0 0] x2 + [2]
                                               [0 1]      [0 1]      [0]
                                                                        
                         [bfs#1](x1, x2, x3) = [0 0] x1 + [0 0] x2 + [2]
                                               [0 1]      [0 1]      [0]
                                                                        
                     [bfs#3](x1, x2, x3, x4) = [0 0] x1 + [0 0] x2 + [0
                                                                      0] x3 + [2]
                                               [0 1]      [0 1]      [0
                                                                      1]      [0]
                                                                                 
                             [bfs#2](x1, x2) = [0 0] x1 + [2]
                                               [0 1]      [0]
                                                             
                               [reverse](x1) = [2 0] x1 + [1]
                                               [0 1]      [0]
                                                             
                                      [leaf] = [1]
                                               [0]
                                                  
                          [node](x1, x2, x3) = [0 0] x1 + [0 0] x2 + [0
                                                                      0] x3 + [1]
                                               [1 0]      [1 1]      [1
                                                                      1]      [1]
                                                                                 
         [bfs#4](x1, x2, x3, x4, x5, x6, x7) = [0 0] x2 + [0 0] x3 + [0
                                                                      0] x4 + [0 0] x5 + [0
                                                                                          0] x7 + [2]
                                               [0 1]      [1 1]      [1
                                                                      1]      [0 1]      [1
                                                                                          0]      [1]
                                                                                                     
                                    [#false] = [0]
                                               [2]
                                                  
                                     [#true] = [0]
                                               [0]
                                                  
                             [dobfs](x1, x2) = [0 0] x1 + [2]
                                               [1 1]      [0]
                                                             
                              [#and](x1, x2) = [0]
                                               [2]
                                                  
                                        [#0] = [1]
                                               [0]
                                                  
                                  [#neg](x1) = [1 1] x1 + [2]
                                               [0 0]      [0]
                                                             
                                  [#pos](x1) = [1 1] x1 + [1]
                                               [0 0]      [0]
                                                             
                                    [#s](x1) = [1 1] x1 + [2]
                                               [0 0]      [0]
                                                             
                          [#equal^#](x1, x2) = [0]
                                               [0]
                                                  
                             [#eq^#](x1, x2) = [0]
                                               [0]
                                                  
                   [appendreverse^#](x1, x2) = [1 0] x1 + [0]
                                               [0 0]      [1]
                                                             
                 [appendreverse#1^#](x1, x2) = [1 0] x1 + [0]
                                               [0 0]      [0]
                                                             
                         [bfs^#](x1, x2, x3) = [0 2] x1 + [1 2] x2 + [2
                                                                      2] x3 + [1]
                                               [0 0]      [0 0]      [0
                                                                      0]      [0]
                                                                                 
                       [bfs#1^#](x1, x2, x3) = [0 2] x1 + [1 2] x2 + [2
                                                                      2] x3 + [1]
                                               [0 0]      [0 0]      [0
                                                                      0]      [0]
                                                                                 
                   [bfs#3^#](x1, x2, x3, x4) = [0 2] x1 + [1 2] x2 + [0
                                                                      2] x3 + [2 2] x4 + [1]
                                               [0 0]      [0 0]      [0
                                                                      0]      [0 0]      [0]
                                                                                            
                           [bfs#2^#](x1, x2) = [1 2] x1 + [2 2] x2 + [0]
                                               [0 0]      [0 0]      [0]
                                                                        
       [bfs#4^#](x1, x2, x3, x4, x5, x6, x7) = [2 2] x1 + [1 2] x2 + [0
                                                                      2] x3 + [0 2] x4 + [0
                                                                                          2] x5 + [2
                                                                                                   2] x6 + [1]
                                               [0 0]      [0 0]      [0
                                                                      0]      [0 0]      [0
                                                                                          0]      [0
                                                                                                   0]      [0]
                                                                                                              
                             [reverse^#](x1) = [1 2] x1 + [0]
                                               [0 0]      [0]
                                                             
                            [bfs2^#](x1, x2) = [2 2] x1 + [2 2] x2 + [2]
                                               [2 1]      [1 1]      [1]
                                                                        
                          [bfs2#1^#](x1, x2) = [0 2] x1 + [2 2] x2 + [2]
                                               [0 0]      [0 0]      [0]
                                                                        
                           [dobfs^#](x1, x2) = [0 2] x1 + [2 2] x2 + [2]
                                               [0 0]      [0 0]      [0]
                                                                        
                             [dfs^#](x1, x2) = [0]
                                               [0]
                                                  
                           [dfs#1^#](x1, x2) = [0]
                                               [0]
                                                  
                   [dfs#2^#](x1, x2, x3, x4) = [0]
                                               [0]
                                                  
           [dfs#3^#](x1, x2, x3, x4, x5, x6) = [0]
                                               [0]
                                                  
                           [dodfs^#](x1, x2) = [0]
                                               [0]
                                                  
                            [#and^#](x1, x2) = [0]
                                               [0]
                                                  
                                   [c_1](x1) = [1 1] x1 + [0]
                                               [0 0]      [0]
                                                             
                                   [c_2](x1) = [1 1] x1 + [0]
                                               [0 0]      [0]
                                                             
                                  [c_10](x1) = [1 0] x1 + [0]
                                               [0 0]      [0]
     
     This order satisfies following ordering constraints
     
                                               [#equal(@x, @y)] =  [0 0] @y + [0]                                                                  
                                                                   [1 0]      [1]                                                                  
                                                                >= [0 0] @y + [0]                                                                  
                                                                   [1 0]      [1]                                                                  
                                                                =  [#eq(@x, @y)]                                                                   
                                                                                                                                                   
                          [#eq(::(@x_1, @x_2), ::(@y_1, @y_2))] =  [0 0] @y_2 + [0]                                                                
                                                                   [1 0]        [3]                                                                
                                                                >= [0]                                                                             
                                                                   [2]                                                                             
                                                                =  [#and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))]                                        
                                                                                                                                                   
                                   [#eq(::(@x_1, @x_2), nil())] =  [0]                                                                             
                                                                   [2]                                                                             
                                                                >= [0]                                                                             
                                                                   [2]                                                                             
                                                                =  [#false()]                                                                      
                                                                                                                                                   
                                  [#eq(::(@x_1, @x_2), leaf())] =  [0]                                                                             
                                                                   [2]                                                                             
                                                                >= [0]                                                                             
                                                                   [2]                                                                             
                                                                =  [#false()]                                                                      
                                                                                                                                                   
                  [#eq(::(@x_1, @x_2), node(@y_1, @y_2, @y_3))] =  [0]                                                                             
                                                                   [2]                                                                             
                                                                >= [0]                                                                             
                                                                   [2]                                                                             
                                                                =  [#false()]                                                                      
                                                                                                                                                   
                                   [#eq(nil(), ::(@y_1, @y_2))] =  [0 0] @y_2 + [0]                                                                
                                                                   [1 0]        [3]                                                                
                                                                >= [0]                                                                             
                                                                   [2]                                                                             
                                                                =  [#false()]                                                                      
                                                                                                                                                   
                                            [#eq(nil(), nil())] =  [0]                                                                             
                                                                   [2]                                                                             
                                                                >= [0]                                                                             
                                                                   [0]                                                                             
                                                                =  [#true()]                                                                       
                                                                                                                                                   
                                           [#eq(nil(), leaf())] =  [0]                                                                             
                                                                   [2]                                                                             
                                                                >= [0]                                                                             
                                                                   [2]                                                                             
                                                                =  [#false()]                                                                      
                                                                                                                                                   
                           [#eq(nil(), node(@y_1, @y_2, @y_3))] =  [0]                                                                             
                                                                   [2]                                                                             
                                                                >= [0]                                                                             
                                                                   [2]                                                                             
                                                                =  [#false()]                                                                      
                                                                                                                                                   
                                  [#eq(leaf(), ::(@y_1, @y_2))] =  [0 0] @y_2 + [0]                                                                
                                                                   [1 0]        [3]                                                                
                                                                >= [0]                                                                             
                                                                   [2]                                                                             
                                                                =  [#false()]                                                                      
                                                                                                                                                   
                                           [#eq(leaf(), nil())] =  [0]                                                                             
                                                                   [2]                                                                             
                                                                >= [0]                                                                             
                                                                   [2]                                                                             
                                                                =  [#false()]                                                                      
                                                                                                                                                   
                                          [#eq(leaf(), leaf())] =  [0]                                                                             
                                                                   [2]                                                                             
                                                                >= [0]                                                                             
                                                                   [0]                                                                             
                                                                =  [#true()]                                                                       
                                                                                                                                                   
                          [#eq(leaf(), node(@y_1, @y_2, @y_3))] =  [0]                                                                             
                                                                   [2]                                                                             
                                                                >= [0]                                                                             
                                                                   [2]                                                                             
                                                                =  [#false()]                                                                      
                                                                                                                                                   
                  [#eq(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2))] =  [0 0] @y_2 + [0]                                                                
                                                                   [1 0]        [3]                                                                
                                                                >= [0]                                                                             
                                                                   [2]                                                                             
                                                                =  [#false()]                                                                      
                                                                                                                                                   
                           [#eq(node(@x_1, @x_2, @x_3), nil())] =  [0]                                                                             
                                                                   [2]                                                                             
                                                                >= [0]                                                                             
                                                                   [2]                                                                             
                                                                =  [#false()]                                                                      
                                                                                                                                                   
                          [#eq(node(@x_1, @x_2, @x_3), leaf())] =  [0]                                                                             
                                                                   [2]                                                                             
                                                                >= [0]                                                                             
                                                                   [2]                                                                             
                                                                =  [#false()]                                                                      
                                                                                                                                                   
          [#eq(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3))] =  [0]                                                                             
                                                                   [2]                                                                             
                                                                >= [0]                                                                             
                                                                   [2]                                                                             
                                                                =  [#and(#eq(@x_1, @y_1), #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3)))]                 
                                                                                                                                                   
                                              [#eq(#0(), #0())] =  [0]                                                                             
                                                                   [2]                                                                             
                                                                >= [0]                                                                             
                                                                   [0]                                                                             
                                                                =  [#true()]                                                                       
                                                                                                                                                   
                                          [#eq(#0(), #neg(@y))] =  [0 0] @y + [0]                                                                  
                                                                   [1 1]      [3]                                                                  
                                                                >= [0]                                                                             
                                                                   [2]                                                                             
                                                                =  [#false()]                                                                      
                                                                                                                                                   
                                          [#eq(#0(), #pos(@y))] =  [0 0] @y + [0]                                                                  
                                                                   [1 1]      [2]                                                                  
                                                                >= [0]                                                                             
                                                                   [2]                                                                             
                                                                =  [#false()]                                                                      
                                                                                                                                                   
                                            [#eq(#0(), #s(@y))] =  [0 0] @y + [0]                                                                  
                                                                   [1 1]      [3]                                                                  
                                                                >= [0]                                                                             
                                                                   [2]                                                                             
                                                                =  [#false()]                                                                      
                                                                                                                                                   
                                          [#eq(#neg(@x), #0())] =  [0]                                                                             
                                                                   [2]                                                                             
                                                                >= [0]                                                                             
                                                                   [2]                                                                             
                                                                =  [#false()]                                                                      
                                                                                                                                                   
                                      [#eq(#neg(@x), #neg(@y))] =  [0 0] @y + [0]                                                                  
                                                                   [1 1]      [3]                                                                  
                                                                >= [0 0] @y + [0]                                                                  
                                                                   [1 0]      [1]                                                                  
                                                                =  [#eq(@x, @y)]                                                                   
                                                                                                                                                   
                                      [#eq(#neg(@x), #pos(@y))] =  [0 0] @y + [0]                                                                  
                                                                   [1 1]      [2]                                                                  
                                                                >= [0]                                                                             
                                                                   [2]                                                                             
                                                                =  [#false()]                                                                      
                                                                                                                                                   
                                          [#eq(#pos(@x), #0())] =  [0]                                                                             
                                                                   [2]                                                                             
                                                                >= [0]                                                                             
                                                                   [2]                                                                             
                                                                =  [#false()]                                                                      
                                                                                                                                                   
                                      [#eq(#pos(@x), #neg(@y))] =  [0 0] @y + [0]                                                                  
                                                                   [1 1]      [3]                                                                  
                                                                >= [0]                                                                             
                                                                   [2]                                                                             
                                                                =  [#false()]                                                                      
                                                                                                                                                   
                                      [#eq(#pos(@x), #pos(@y))] =  [0 0] @y + [0]                                                                  
                                                                   [1 1]      [2]                                                                  
                                                                >= [0 0] @y + [0]                                                                  
                                                                   [1 0]      [1]                                                                  
                                                                =  [#eq(@x, @y)]                                                                   
                                                                                                                                                   
                                            [#eq(#s(@x), #0())] =  [0]                                                                             
                                                                   [2]                                                                             
                                                                >= [0]                                                                             
                                                                   [2]                                                                             
                                                                =  [#false()]                                                                      
                                                                                                                                                   
                                          [#eq(#s(@x), #s(@y))] =  [0 0] @y + [0]                                                                  
                                                                   [1 1]      [3]                                                                  
                                                                >= [0 0] @y + [0]                                                                  
                                                                   [1 0]      [1]                                                                  
                                                                =  [#eq(@x, @y)]                                                                   
                                                                                                                                                   
                            [appendreverse(@toreverse, @sofar)] =  [1 0] @sofar + [1 0] @toreverse + [0]                                           
                                                                   [0 1]          [0 1]              [0]                                           
                                                                >= [1 0] @sofar + [1 0] @toreverse + [0]                                           
                                                                   [0 1]          [0 1]              [0]                                           
                                                                =  [appendreverse#1(@toreverse, @sofar)]                                           
                                                                                                                                                   
                         [appendreverse#1(::(@a, @as), @sofar)] =  [0 0] @a + [1 0] @as + [1 0] @sofar + [2]                                       
                                                                   [0 1]      [0 1]       [0 1]          [0]                                       
                                                                >= [0 0] @a + [1 0] @as + [1 0] @sofar + [2]                                       
                                                                   [0 1]      [0 1]       [0 1]          [0]                                       
                                                                =  [appendreverse(@as, ::(@a, @sofar))]                                            
                                                                                                                                                   
                               [appendreverse#1(nil(), @sofar)] =  [1 0] @sofar + [1]                                                              
                                                                   [0 1]          [0]                                                              
                                                                >  [1 0] @sofar + [0]                                                              
                                                                   [0 1]          [0]                                                              
                                                                =  [@sofar]                                                                        
                                                                                                                                                   
                                [bfs(@queue, @futurequeue, @x)] =  [0 0] @futurequeue + [0 0] @queue + [2]                                         
                                                                   [0 1]                [0 1]          [0]                                         
                                                                >= [0 0] @futurequeue + [0 0] @queue + [2]                                         
                                                                   [0 1]                [0 1]          [0]                                         
                                                                =  [bfs#1(@queue, @futurequeue, @x)]                                               
                                                                                                                                                   
                         [bfs#1(::(@t, @ts), @futurequeue, @x)] =  [0 0] @futurequeue + [0 0] @t + [0 0] @ts + [2]                                 
                                                                   [0 1]                [0 1]      [0 1]       [0]                                 
                                                                >= [0 0] @futurequeue + [0 0] @t + [0 0] @ts + [2]                                 
                                                                   [0 1]                [0 1]      [0 1]       [0]                                 
                                                                =  [bfs#3(@t, @futurequeue, @ts, @x)]                                              
                                                                                                                                                   
                               [bfs#1(nil(), @futurequeue, @x)] =  [0 0] @futurequeue + [2]                                                        
                                                                   [0 1]                [0]                                                        
                                                                >= [0 0] @futurequeue + [2]                                                        
                                                                   [0 1]                [0]                                                        
                                                                =  [bfs#2(@futurequeue, @x)]                                                       
                                                                                                                                                   
                         [bfs#3(leaf(), @futurequeue, @ts, @x)] =  [0 0] @futurequeue + [0 0] @ts + [2]                                            
                                                                   [0 1]                [0 1]       [0]                                            
                                                                >= [0 0] @futurequeue + [0 0] @ts + [2]                                            
                                                                   [0 1]                [0 1]       [0]                                            
                                                                =  [bfs(@ts, @futurequeue, @x)]                                                    
                                                                                                                                                   
             [bfs#3(node(@y, @t1, @t2), @futurequeue, @ts, @x)] =  [0 0] @futurequeue + [0 0] @t1 + [0 0] @t2 + [0 0] @ts + [0                     
                                                                                                                             0] @y + [2]           
                                                                   [0 1]                [1 1]       [1 1]       [0 1]       [1                     
                                                                                                                             0]      [1]           
                                                                >= [0 0] @futurequeue + [0 0] @t1 + [0 0] @t2 + [0 0] @ts + [0                     
                                                                                                                             0] @y + [2]           
                                                                   [0 1]                [1 1]       [1 1]       [0 1]       [1                     
                                                                                                                             0]      [1]           
                                                                =  [bfs#4(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y)]                    
                                                                                                                                                   
                                       [bfs#2(::(@t, @ts), @x)] =  [0 0] @t + [0 0] @ts + [2]                                                      
                                                                   [0 1]      [0 1]       [0]                                                      
                                                                >= [0 0] @t + [0 0] @ts + [2]                                                      
                                                                   [0 1]      [0 1]       [0]                                                      
                                                                =  [bfs(reverse(::(@t, @ts)), nil(), @x)]                                          
                                                                                                                                                   
                                             [bfs#2(nil(), @x)] =  [2]                                                                             
                                                                   [0]                                                                             
                                                                >  [1]                                                                             
                                                                   [0]                                                                             
                                                                =  [leaf()]                                                                        
                                                                                                                                                   
                                                 [reverse(@xs)] =  [2 0] @xs + [1]                                                                 
                                                                   [0 1]       [0]                                                                 
                                                                >= [1 0] @xs + [1]                                                                 
                                                                   [0 1]       [0]                                                                 
                                                                =  [appendreverse(@xs, nil())]                                                     
                                                                                                                                                   
         [bfs#4(#false(), @futurequeue, @t1, @t2, @ts, @x, @y)] =  [0 0] @futurequeue + [0 0] @t1 + [0 0] @t2 + [0 0] @ts + [0                     
                                                                                                                             0] @y + [2]           
                                                                   [0 1]                [1 1]       [1 1]       [0 1]       [1                     
                                                                                                                             0]      [1]           
                                                                >= [0 0] @futurequeue + [0 0] @t1 + [0 0] @t2 + [0 0] @ts + [2]                    
                                                                   [0 1]                [0 1]       [0 1]       [0 1]       [0]                    
                                                                =  [bfs(@ts, ::(@t2, ::(@t1, @futurequeue)), @x)]                                  
                                                                                                                                                   
          [bfs#4(#true(), @futurequeue, @t1, @t2, @ts, @x, @y)] =  [0 0] @futurequeue + [0 0] @t1 + [0 0] @t2 + [0 0] @ts + [0                     
                                                                                                                             0] @y + [2]           
                                                                   [0 1]                [1 1]       [1 1]       [0 1]       [1                     
                                                                                                                             0]      [1]           
                                                                >  [0 0] @t1 + [0 0] @t2 + [0 0] @y + [1]                                          
                                                                   [1 1]       [1 1]       [1 0]      [1]                                          
                                                                =  [node(@y, @t1, @t2)]                                                            
                                                                                                                                                   
                                                [dobfs(@t, @x)] =  [0 0] @t + [2]                                                                  
                                                                   [1 1]      [0]                                                                  
                                                                >= [0 0] @t + [2]                                                                  
                                                                   [0 1]      [0]                                                                  
                                                                =  [bfs(::(@t, nil()), nil(), @x)]                                                 
                                                                                                                                                   
                                     [#and(#false(), #false())] =  [0]                                                                             
                                                                   [2]                                                                             
                                                                >= [0]                                                                             
                                                                   [2]                                                                             
                                                                =  [#false()]                                                                      
                                                                                                                                                   
                                      [#and(#false(), #true())] =  [0]                                                                             
                                                                   [2]                                                                             
                                                                >= [0]                                                                             
                                                                   [2]                                                                             
                                                                =  [#false()]                                                                      
                                                                                                                                                   
                                      [#and(#true(), #false())] =  [0]                                                                             
                                                                   [2]                                                                             
                                                                >= [0]                                                                             
                                                                   [2]                                                                             
                                                                =  [#false()]                                                                      
                                                                                                                                                   
                                       [#and(#true(), #true())] =  [0]                                                                             
                                                                   [2]                                                                             
                                                                >= [0]                                                                             
                                                                   [0]                                                                             
                                                                =  [#true()]                                                                       
                                                                                                                                                   
                          [appendreverse^#(@toreverse, @sofar)] =  [1 0] @toreverse + [0]                                                          
                                                                   [0 0]              [1]                                                          
                                                                >= [1 0] @toreverse + [0]                                                          
                                                                   [0 0]              [0]                                                          
                                                                =  [c_1(appendreverse#1^#(@toreverse, @sofar))]                                    
                                                                                                                                                   
                       [appendreverse#1^#(::(@a, @as), @sofar)] =  [1 0] @as + [2]                                                                 
                                                                   [0 0]       [0]                                                                 
                                                                >  [1 0] @as + [1]                                                                 
                                                                   [0 0]       [0]                                                                 
                                                                =  [c_2(appendreverse^#(@as, ::(@a, @sofar)))]                                     
                                                                                                                                                   
                              [bfs^#(@queue, @futurequeue, @x)] =  [1 2] @futurequeue + [0 2] @queue + [2 2] @x + [1]                              
                                                                   [0 0]                [0 0]          [0 0]      [0]                              
                                                                >= [1 2] @futurequeue + [0 2] @queue + [2 2] @x + [1]                              
                                                                   [0 0]                [0 0]          [0 0]      [0]                              
                                                                =  [bfs#1^#(@queue, @futurequeue, @x)]                                             
                                                                                                                                                   
                       [bfs#1^#(::(@t, @ts), @futurequeue, @x)] =  [1 2] @futurequeue + [0 2] @t + [0 2] @ts + [2 2] @x + [1]                      
                                                                   [0 0]                [0 0]      [0 0]       [0 0]      [0]                      
                                                                >= [1 2] @futurequeue + [0 2] @t + [0 2] @ts + [2 2] @x + [1]                      
                                                                   [0 0]                [0 0]      [0 0]       [0 0]      [0]                      
                                                                =  [bfs#3^#(@t, @futurequeue, @ts, @x)]                                            
                                                                                                                                                   
                             [bfs#1^#(nil(), @futurequeue, @x)] =  [1 2] @futurequeue + [2 2] @x + [1]                                             
                                                                   [0 0]                [0 0]      [0]                                             
                                                                >  [1 2] @futurequeue + [2 2] @x + [0]                                             
                                                                   [0 0]                [0 0]      [0]                                             
                                                                =  [bfs#2^#(@futurequeue, @x)]                                                     
                                                                                                                                                   
                       [bfs#3^#(leaf(), @futurequeue, @ts, @x)] =  [1 2] @futurequeue + [0 2] @ts + [2 2] @x + [1]                                 
                                                                   [0 0]                [0 0]       [0 0]      [0]                                 
                                                                >= [1 2] @futurequeue + [0 2] @ts + [2 2] @x + [1]                                 
                                                                   [0 0]                [0 0]       [0 0]      [0]                                 
                                                                =  [bfs^#(@ts, @futurequeue, @x)]                                                  
                                                                                                                                                   
           [bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x)] =  [1 2] @futurequeue + [2 2] @t1 + [2 2] @t2 + [0 2] @ts + [2                     
                                                                                                                             2] @x + [2 0] @y + [3]
                                                                   [0 0]                [0 0]       [0 0]       [0 0]       [0                     
                                                                                                                             0]      [0 0]      [0]
                                                                >= [1 2] @futurequeue + [0 2] @t1 + [0 2] @t2 + [0 2] @ts + [2                     
                                                                                                                             2] @x + [2 0] @y + [3]
                                                                   [0 0]                [0 0]       [0 0]       [0 0]       [0                     
                                                                                                                             0]      [0 0]      [0]
                                                                =  [bfs#4^#(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y)]                  
                                                                                                                                                   
                                     [bfs#2^#(::(@t, @ts), @x)] =  [0 2] @t + [1 2] @ts + [2 2] @x + [2]                                           
                                                                   [0 0]      [0 0]       [0 0]      [0]                                           
                                                                >= [0 2] @t + [0 2] @ts + [2 2] @x + [2]                                           
                                                                   [0 0]      [0 0]       [0 0]      [0]                                           
                                                                =  [bfs^#(reverse(::(@t, @ts)), nil(), @x)]                                        
                                                                                                                                                   
                                     [bfs#2^#(::(@t, @ts), @x)] =  [0 2] @t + [1 2] @ts + [2 2] @x + [2]                                           
                                                                   [0 0]      [0 0]       [0 0]      [0]                                           
                                                                >= [0 2] @t + [1 2] @ts + [2]                                                      
                                                                   [0 0]      [0 0]       [0]                                                      
                                                                =  [reverse^#(::(@t, @ts))]                                                        
                                                                                                                                                   
       [bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y)] =  [1 2] @futurequeue + [0 2] @t1 + [0 2] @t2 + [0 2] @ts + [2                     
                                                                                                                             2] @x + [5]           
                                                                   [0 0]                [0 0]       [0 0]       [0 0]       [0                     
                                                                                                                             0]      [0]           
                                                                >= [1 2] @futurequeue + [0 2] @t1 + [0 2] @t2 + [0 2] @ts + [2                     
                                                                                                                             2] @x + [5]           
                                                                   [0 0]                [0 0]       [0 0]       [0 0]       [0                     
                                                                                                                             0]      [0]           
                                                                =  [bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x)]                                
                                                                                                                                                   
                                               [reverse^#(@xs)] =  [1 2] @xs + [0]                                                                 
                                                                   [0 0]       [0]                                                                 
                                                                >= [1 0] @xs + [0]                                                                 
                                                                   [0 0]       [0]                                                                 
                                                                =  [c_10(appendreverse^#(@xs, nil()))]                                             
                                                                                                                                                   
                                               [bfs2^#(@t, @x)] =  [2 2] @t + [2 2] @x + [2]                                                       
                                                                   [2 1]      [1 1]      [1]                                                       
                                                                >= [2 2] @t + [2 2] @x + [2]                                                       
                                                                   [0 0]      [0 0]      [0]                                                       
                                                                =  [bfs2#1^#(dobfs(@t, @x), @x)]                                                   
                                                                                                                                                   
                                            [bfs2#1^#(@t', @x)] =  [0 2] @t' + [2 2] @x + [2]                                                      
                                                                   [0 0]       [0 0]      [0]                                                      
                                                                >= [0 2] @t' + [2 2] @x + [2]                                                      
                                                                   [0 0]       [0 0]      [0]                                                      
                                                                =  [dobfs^#(@t', @x)]                                                              
                                                                                                                                                   
                                              [dobfs^#(@t, @x)] =  [0 2] @t + [2 2] @x + [2]                                                       
                                                                   [0 0]      [0 0]      [0]                                                       
                                                                >= [0 2] @t + [2 2] @x + [2]                                                       
                                                                   [0 0]      [0 0]      [0]                                                       
                                                                =  [bfs^#(::(@t, nil()), nil(), @x)]                                               
                                                                                                                                                   
   
   Consider the set of all dependency pairs
   
   DPs:
     { 1: appendreverse^#(@toreverse, @sofar) ->
          c_1(appendreverse#1^#(@toreverse, @sofar))
     , 2: reverse^#(@xs) -> c_10(appendreverse^#(@xs, nil()))
     , 3: appendreverse#1^#(::(@a, @as), @sofar) ->
          c_2(appendreverse^#(@as, ::(@a, @sofar)))
     , 4: bfs^#(@queue, @futurequeue, @x) ->
          bfs#1^#(@queue, @futurequeue, @x)
     , 5: bfs#1^#(::(@t, @ts), @futurequeue, @x) ->
          bfs#3^#(@t, @futurequeue, @ts, @x)
     , 6: bfs#1^#(nil(), @futurequeue, @x) -> bfs#2^#(@futurequeue, @x)
     , 7: bfs#3^#(leaf(), @futurequeue, @ts, @x) ->
          bfs^#(@ts, @futurequeue, @x)
     , 8: bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
          bfs#4^#(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y)
     , 9: bfs#2^#(::(@t, @ts), @x) ->
          bfs^#(reverse(::(@t, @ts)), nil(), @x)
     , 10: bfs#2^#(::(@t, @ts), @x) -> reverse^#(::(@t, @ts))
     , 11: bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
           bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x)
     , 12: bfs2^#(@t, @x) -> bfs2#1^#(dobfs(@t, @x), @x)
     , 13: bfs2#1^#(@t', @x) -> dobfs^#(@t', @x)
     , 14: dobfs^#(@t, @x) -> bfs^#(::(@t, nil()), nil(), @x) }
   
   Processor 'matrix interpretation of dimension 2' induces the
   complexity certificate YES(?,O(n^1)) on application of dependency
   pairs {3,6}. These cover all (indirect) predecessors of dependency
   pairs {1,2,3,6,9,10,12,13,14}, their number of application is
   equally bounded. The dependency pairs are shifted into the
   corresponding weak component(s).
   
   We apply the transformation 'removetails' on the sub-problem:
   
   Weak DPs:
     { appendreverse^#(@toreverse, @sofar) ->
       c_1(appendreverse#1^#(@toreverse, @sofar))
     , appendreverse#1^#(::(@a, @as), @sofar) ->
       c_2(appendreverse^#(@as, ::(@a, @sofar)))
     , bfs^#(@queue, @futurequeue, @x) ->
       bfs#1^#(@queue, @futurequeue, @x)
     , bfs#1^#(::(@t, @ts), @futurequeue, @x) ->
       bfs#3^#(@t, @futurequeue, @ts, @x)
     , bfs#1^#(nil(), @futurequeue, @x) -> bfs#2^#(@futurequeue, @x)
     , bfs#3^#(leaf(), @futurequeue, @ts, @x) ->
       bfs^#(@ts, @futurequeue, @x)
     , bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
       bfs#4^#(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y)
     , bfs#2^#(::(@t, @ts), @x) ->
       bfs^#(reverse(::(@t, @ts)), nil(), @x)
     , bfs#2^#(::(@t, @ts), @x) -> reverse^#(::(@t, @ts))
     , bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
       bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x)
     , reverse^#(@xs) -> c_10(appendreverse^#(@xs, nil()))
     , bfs2^#(@t, @x) -> bfs2#1^#(dobfs(@t, @x), @x)
     , bfs2#1^#(@t', @x) -> dobfs^#(@t', @x)
     , dobfs^#(@t, @x) -> bfs^#(::(@t, nil()), nil(), @x) }
   Weak Trs:
     { #equal(@x, @y) -> #eq(@x, @y)
     , #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
       #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
     , #eq(::(@x_1, @x_2), nil()) -> #false()
     , #eq(::(@x_1, @x_2), leaf()) -> #false()
     , #eq(::(@x_1, @x_2), node(@y_1, @y_2, @y_3)) -> #false()
     , #eq(nil(), ::(@y_1, @y_2)) -> #false()
     , #eq(nil(), nil()) -> #true()
     , #eq(nil(), leaf()) -> #false()
     , #eq(nil(), node(@y_1, @y_2, @y_3)) -> #false()
     , #eq(leaf(), ::(@y_1, @y_2)) -> #false()
     , #eq(leaf(), nil()) -> #false()
     , #eq(leaf(), leaf()) -> #true()
     , #eq(leaf(), node(@y_1, @y_2, @y_3)) -> #false()
     , #eq(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2)) -> #false()
     , #eq(node(@x_1, @x_2, @x_3), nil()) -> #false()
     , #eq(node(@x_1, @x_2, @x_3), leaf()) -> #false()
     , #eq(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) ->
       #and(#eq(@x_1, @y_1), #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3)))
     , #eq(#0(), #0()) -> #true()
     , #eq(#0(), #neg(@y)) -> #false()
     , #eq(#0(), #pos(@y)) -> #false()
     , #eq(#0(), #s(@y)) -> #false()
     , #eq(#neg(@x), #0()) -> #false()
     , #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
     , #eq(#neg(@x), #pos(@y)) -> #false()
     , #eq(#pos(@x), #0()) -> #false()
     , #eq(#pos(@x), #neg(@y)) -> #false()
     , #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
     , #eq(#s(@x), #0()) -> #false()
     , #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
     , appendreverse(@toreverse, @sofar) ->
       appendreverse#1(@toreverse, @sofar)
     , appendreverse#1(::(@a, @as), @sofar) ->
       appendreverse(@as, ::(@a, @sofar))
     , appendreverse#1(nil(), @sofar) -> @sofar
     , bfs(@queue, @futurequeue, @x) -> bfs#1(@queue, @futurequeue, @x)
     , bfs#1(::(@t, @ts), @futurequeue, @x) ->
       bfs#3(@t, @futurequeue, @ts, @x)
     , bfs#1(nil(), @futurequeue, @x) -> bfs#2(@futurequeue, @x)
     , bfs#3(leaf(), @futurequeue, @ts, @x) ->
       bfs(@ts, @futurequeue, @x)
     , bfs#3(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
       bfs#4(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y)
     , bfs#2(::(@t, @ts), @x) -> bfs(reverse(::(@t, @ts)), nil(), @x)
     , bfs#2(nil(), @x) -> leaf()
     , reverse(@xs) -> appendreverse(@xs, nil())
     , bfs#4(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
       bfs(@ts, ::(@t2, ::(@t1, @futurequeue)), @x)
     , bfs#4(#true(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
       node(@y, @t1, @t2)
     , dobfs(@t, @x) -> bfs(::(@t, nil()), nil(), @x)
     , #and(#false(), #false()) -> #false()
     , #and(#false(), #true()) -> #false()
     , #and(#true(), #false()) -> #false()
     , #and(#true(), #true()) -> #true() }
   StartTerms: basic terms
   Strategy: innermost
   
   The following weak DPs constitute a sub-graph of the DG that is
   closed under successors. The DPs are removed.
   
   { appendreverse^#(@toreverse, @sofar) ->
     c_1(appendreverse#1^#(@toreverse, @sofar))
   , appendreverse#1^#(::(@a, @as), @sofar) ->
     c_2(appendreverse^#(@as, ::(@a, @sofar)))
   , bfs^#(@queue, @futurequeue, @x) ->
     bfs#1^#(@queue, @futurequeue, @x)
   , bfs#1^#(::(@t, @ts), @futurequeue, @x) ->
     bfs#3^#(@t, @futurequeue, @ts, @x)
   , bfs#1^#(nil(), @futurequeue, @x) -> bfs#2^#(@futurequeue, @x)
   , bfs#3^#(leaf(), @futurequeue, @ts, @x) ->
     bfs^#(@ts, @futurequeue, @x)
   , bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
     bfs#4^#(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y)
   , bfs#2^#(::(@t, @ts), @x) ->
     bfs^#(reverse(::(@t, @ts)), nil(), @x)
   , bfs#2^#(::(@t, @ts), @x) -> reverse^#(::(@t, @ts))
   , bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
     bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x)
   , reverse^#(@xs) -> c_10(appendreverse^#(@xs, nil()))
   , bfs2^#(@t, @x) -> bfs2#1^#(dobfs(@t, @x), @x)
   , bfs2#1^#(@t', @x) -> dobfs^#(@t', @x)
   , dobfs^#(@t, @x) -> bfs^#(::(@t, nil()), nil(), @x) }
   
   
   We apply the transformation 'usablerules' on the sub-problem:
   
   Weak Trs:
     { #equal(@x, @y) -> #eq(@x, @y)
     , #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
       #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
     , #eq(::(@x_1, @x_2), nil()) -> #false()
     , #eq(::(@x_1, @x_2), leaf()) -> #false()
     , #eq(::(@x_1, @x_2), node(@y_1, @y_2, @y_3)) -> #false()
     , #eq(nil(), ::(@y_1, @y_2)) -> #false()
     , #eq(nil(), nil()) -> #true()
     , #eq(nil(), leaf()) -> #false()
     , #eq(nil(), node(@y_1, @y_2, @y_3)) -> #false()
     , #eq(leaf(), ::(@y_1, @y_2)) -> #false()
     , #eq(leaf(), nil()) -> #false()
     , #eq(leaf(), leaf()) -> #true()
     , #eq(leaf(), node(@y_1, @y_2, @y_3)) -> #false()
     , #eq(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2)) -> #false()
     , #eq(node(@x_1, @x_2, @x_3), nil()) -> #false()
     , #eq(node(@x_1, @x_2, @x_3), leaf()) -> #false()
     , #eq(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) ->
       #and(#eq(@x_1, @y_1), #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3)))
     , #eq(#0(), #0()) -> #true()
     , #eq(#0(), #neg(@y)) -> #false()
     , #eq(#0(), #pos(@y)) -> #false()
     , #eq(#0(), #s(@y)) -> #false()
     , #eq(#neg(@x), #0()) -> #false()
     , #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
     , #eq(#neg(@x), #pos(@y)) -> #false()
     , #eq(#pos(@x), #0()) -> #false()
     , #eq(#pos(@x), #neg(@y)) -> #false()
     , #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
     , #eq(#s(@x), #0()) -> #false()
     , #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
     , appendreverse(@toreverse, @sofar) ->
       appendreverse#1(@toreverse, @sofar)
     , appendreverse#1(::(@a, @as), @sofar) ->
       appendreverse(@as, ::(@a, @sofar))
     , appendreverse#1(nil(), @sofar) -> @sofar
     , bfs(@queue, @futurequeue, @x) -> bfs#1(@queue, @futurequeue, @x)
     , bfs#1(::(@t, @ts), @futurequeue, @x) ->
       bfs#3(@t, @futurequeue, @ts, @x)
     , bfs#1(nil(), @futurequeue, @x) -> bfs#2(@futurequeue, @x)
     , bfs#3(leaf(), @futurequeue, @ts, @x) ->
       bfs(@ts, @futurequeue, @x)
     , bfs#3(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
       bfs#4(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y)
     , bfs#2(::(@t, @ts), @x) -> bfs(reverse(::(@t, @ts)), nil(), @x)
     , bfs#2(nil(), @x) -> leaf()
     , reverse(@xs) -> appendreverse(@xs, nil())
     , bfs#4(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
       bfs(@ts, ::(@t2, ::(@t1, @futurequeue)), @x)
     , bfs#4(#true(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
       node(@y, @t1, @t2)
     , dobfs(@t, @x) -> bfs(::(@t, nil()), nil(), @x)
     , #and(#false(), #false()) -> #false()
     , #and(#false(), #true()) -> #false()
     , #and(#true(), #false()) -> #false()
     , #and(#true(), #true()) -> #true() }
   StartTerms: basic terms
   Strategy: innermost
   
   No rule is usable, rules are removed from the input problem.
   
   
   We are left with following problem, upon which TcT provides the
   certificate YES(O(1),O(1)).
   
   Rules: Empty
   Obligation:
     innermost runtime complexity
   Answer:
     YES(O(1),O(1))
   
   Empty rules are trivially bounded
   
   Wall-time: 13.679367s
   CPU-time: 105.033s
   
   Wall-time: 17.709499s
   CPU-time: 134.545s

S) We are left with following problem, upon which TcT provides the
   certificate YES(O(1),O(n^1)).
   
   Strict DPs:
     { dfs^#(@queue, @x) -> c_14(dfs#1^#(@queue, @x))
     , dfs#1^#(::(@t, @ts), @x) -> c_15(dfs#2^#(@t, @t, @ts, @x))
     , dfs#2^#(leaf(), @t, @ts, @x) -> c_16(dfs^#(@ts, @x))
     , dfs#2^#(node(@a, @t1, @t2), @t, @ts, @x) ->
       c_17(dfs#3^#(#equal(@a, @x), @t, @t1, @t2, @ts, @x))
     , dfs#3^#(#false(), @t, @t1, @t2, @ts, @x) ->
       c_18(dfs^#(::(@t1, ::(@t2, @ts)), @x)) }
   Weak DPs:
     { appendreverse^#(@toreverse, @sofar) ->
       c_1(appendreverse#1^#(@toreverse, @sofar))
     , appendreverse#1^#(::(@a, @as), @sofar) ->
       c_2(appendreverse^#(@as, ::(@a, @sofar)))
     , bfs^#(@queue, @futurequeue, @x) ->
       c_3(bfs#1^#(@queue, @futurequeue, @x))
     , bfs#1^#(::(@t, @ts), @futurequeue, @x) ->
       c_4(bfs#3^#(@t, @futurequeue, @ts, @x))
     , bfs#1^#(nil(), @futurequeue, @x) ->
       c_5(bfs#2^#(@futurequeue, @x))
     , bfs#3^#(leaf(), @futurequeue, @ts, @x) ->
       c_6(bfs^#(@ts, @futurequeue, @x))
     , bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
       c_7(bfs#4^#(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y))
     , bfs#2^#(::(@t, @ts), @x) ->
       c_8(bfs^#(reverse(::(@t, @ts)), nil(), @x), reverse^#(::(@t, @ts)))
     , bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
       c_9(bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x))
     , reverse^#(@xs) -> c_10(appendreverse^#(@xs, nil()))
     , bfs2^#(@t, @x) ->
       c_11(bfs2#1^#(dobfs(@t, @x), @x), dobfs^#(@t, @x))
     , bfs2#1^#(@t', @x) -> c_12(dobfs^#(@t', @x))
     , dobfs^#(@t, @x) -> c_13(bfs^#(::(@t, nil()), nil(), @x)) }
   Weak Trs:
     { #equal(@x, @y) -> #eq(@x, @y)
     , #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
       #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
     , #eq(::(@x_1, @x_2), nil()) -> #false()
     , #eq(::(@x_1, @x_2), leaf()) -> #false()
     , #eq(::(@x_1, @x_2), node(@y_1, @y_2, @y_3)) -> #false()
     , #eq(nil(), ::(@y_1, @y_2)) -> #false()
     , #eq(nil(), nil()) -> #true()
     , #eq(nil(), leaf()) -> #false()
     , #eq(nil(), node(@y_1, @y_2, @y_3)) -> #false()
     , #eq(leaf(), ::(@y_1, @y_2)) -> #false()
     , #eq(leaf(), nil()) -> #false()
     , #eq(leaf(), leaf()) -> #true()
     , #eq(leaf(), node(@y_1, @y_2, @y_3)) -> #false()
     , #eq(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2)) -> #false()
     , #eq(node(@x_1, @x_2, @x_3), nil()) -> #false()
     , #eq(node(@x_1, @x_2, @x_3), leaf()) -> #false()
     , #eq(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) ->
       #and(#eq(@x_1, @y_1), #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3)))
     , #eq(#0(), #0()) -> #true()
     , #eq(#0(), #neg(@y)) -> #false()
     , #eq(#0(), #pos(@y)) -> #false()
     , #eq(#0(), #s(@y)) -> #false()
     , #eq(#neg(@x), #0()) -> #false()
     , #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
     , #eq(#neg(@x), #pos(@y)) -> #false()
     , #eq(#pos(@x), #0()) -> #false()
     , #eq(#pos(@x), #neg(@y)) -> #false()
     , #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
     , #eq(#s(@x), #0()) -> #false()
     , #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
     , appendreverse(@toreverse, @sofar) ->
       appendreverse#1(@toreverse, @sofar)
     , appendreverse#1(::(@a, @as), @sofar) ->
       appendreverse(@as, ::(@a, @sofar))
     , appendreverse#1(nil(), @sofar) -> @sofar
     , bfs(@queue, @futurequeue, @x) -> bfs#1(@queue, @futurequeue, @x)
     , bfs#1(::(@t, @ts), @futurequeue, @x) ->
       bfs#3(@t, @futurequeue, @ts, @x)
     , bfs#1(nil(), @futurequeue, @x) -> bfs#2(@futurequeue, @x)
     , bfs#3(leaf(), @futurequeue, @ts, @x) ->
       bfs(@ts, @futurequeue, @x)
     , bfs#3(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
       bfs#4(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y)
     , bfs#2(::(@t, @ts), @x) -> bfs(reverse(::(@t, @ts)), nil(), @x)
     , bfs#2(nil(), @x) -> leaf()
     , reverse(@xs) -> appendreverse(@xs, nil())
     , bfs#4(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
       bfs(@ts, ::(@t2, ::(@t1, @futurequeue)), @x)
     , bfs#4(#true(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
       node(@y, @t1, @t2)
     , bfs2(@t, @x) -> bfs2#1(dobfs(@t, @x), @x)
     , dobfs(@t, @x) -> bfs(::(@t, nil()), nil(), @x)
     , bfs2#1(@t', @x) -> dobfs(@t', @x)
     , dfs(@queue, @x) -> dfs#1(@queue, @x)
     , dfs#1(::(@t, @ts), @x) -> dfs#2(@t, @t, @ts, @x)
     , dfs#1(nil(), @x) -> leaf()
     , dfs#2(leaf(), @t, @ts, @x) -> dfs(@ts, @x)
     , dfs#2(node(@a, @t1, @t2), @t, @ts, @x) ->
       dfs#3(#equal(@a, @x), @t, @t1, @t2, @ts, @x)
     , dfs#3(#false(), @t, @t1, @t2, @ts, @x) ->
       dfs(::(@t1, ::(@t2, @ts)), @x)
     , dfs#3(#true(), @t, @t1, @t2, @ts, @x) -> @t
     , dodfs(@t, @x) -> dfs(::(@t, nil()), @x)
     , #and(#false(), #false()) -> #false()
     , #and(#false(), #true()) -> #false()
     , #and(#true(), #false()) -> #false()
     , #and(#true(), #true()) -> #true() }
   Obligation:
     innermost runtime complexity
   Answer:
     YES(O(1),O(n^1))
   
   The following weak DPs constitute a sub-graph of the DG that is
   closed under successors. The DPs are removed.
   
   { appendreverse^#(@toreverse, @sofar) ->
     c_1(appendreverse#1^#(@toreverse, @sofar))
   , appendreverse#1^#(::(@a, @as), @sofar) ->
     c_2(appendreverse^#(@as, ::(@a, @sofar)))
   , bfs^#(@queue, @futurequeue, @x) ->
     c_3(bfs#1^#(@queue, @futurequeue, @x))
   , bfs#1^#(::(@t, @ts), @futurequeue, @x) ->
     c_4(bfs#3^#(@t, @futurequeue, @ts, @x))
   , bfs#1^#(nil(), @futurequeue, @x) ->
     c_5(bfs#2^#(@futurequeue, @x))
   , bfs#3^#(leaf(), @futurequeue, @ts, @x) ->
     c_6(bfs^#(@ts, @futurequeue, @x))
   , bfs#3^#(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
     c_7(bfs#4^#(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y))
   , bfs#2^#(::(@t, @ts), @x) ->
     c_8(bfs^#(reverse(::(@t, @ts)), nil(), @x), reverse^#(::(@t, @ts)))
   , bfs#4^#(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
     c_9(bfs^#(@ts, ::(@t2, ::(@t1, @futurequeue)), @x))
   , reverse^#(@xs) -> c_10(appendreverse^#(@xs, nil()))
   , bfs2^#(@t, @x) ->
     c_11(bfs2#1^#(dobfs(@t, @x), @x), dobfs^#(@t, @x))
   , bfs2#1^#(@t', @x) -> c_12(dobfs^#(@t', @x))
   , dobfs^#(@t, @x) -> c_13(bfs^#(::(@t, nil()), nil(), @x)) }
   
   We are left with following problem, upon which TcT provides the
   certificate YES(O(1),O(n^1)).
   
   Strict DPs:
     { dfs^#(@queue, @x) -> c_14(dfs#1^#(@queue, @x))
     , dfs#1^#(::(@t, @ts), @x) -> c_15(dfs#2^#(@t, @t, @ts, @x))
     , dfs#2^#(leaf(), @t, @ts, @x) -> c_16(dfs^#(@ts, @x))
     , dfs#2^#(node(@a, @t1, @t2), @t, @ts, @x) ->
       c_17(dfs#3^#(#equal(@a, @x), @t, @t1, @t2, @ts, @x))
     , dfs#3^#(#false(), @t, @t1, @t2, @ts, @x) ->
       c_18(dfs^#(::(@t1, ::(@t2, @ts)), @x)) }
   Weak Trs:
     { #equal(@x, @y) -> #eq(@x, @y)
     , #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
       #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
     , #eq(::(@x_1, @x_2), nil()) -> #false()
     , #eq(::(@x_1, @x_2), leaf()) -> #false()
     , #eq(::(@x_1, @x_2), node(@y_1, @y_2, @y_3)) -> #false()
     , #eq(nil(), ::(@y_1, @y_2)) -> #false()
     , #eq(nil(), nil()) -> #true()
     , #eq(nil(), leaf()) -> #false()
     , #eq(nil(), node(@y_1, @y_2, @y_3)) -> #false()
     , #eq(leaf(), ::(@y_1, @y_2)) -> #false()
     , #eq(leaf(), nil()) -> #false()
     , #eq(leaf(), leaf()) -> #true()
     , #eq(leaf(), node(@y_1, @y_2, @y_3)) -> #false()
     , #eq(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2)) -> #false()
     , #eq(node(@x_1, @x_2, @x_3), nil()) -> #false()
     , #eq(node(@x_1, @x_2, @x_3), leaf()) -> #false()
     , #eq(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) ->
       #and(#eq(@x_1, @y_1), #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3)))
     , #eq(#0(), #0()) -> #true()
     , #eq(#0(), #neg(@y)) -> #false()
     , #eq(#0(), #pos(@y)) -> #false()
     , #eq(#0(), #s(@y)) -> #false()
     , #eq(#neg(@x), #0()) -> #false()
     , #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
     , #eq(#neg(@x), #pos(@y)) -> #false()
     , #eq(#pos(@x), #0()) -> #false()
     , #eq(#pos(@x), #neg(@y)) -> #false()
     , #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
     , #eq(#s(@x), #0()) -> #false()
     , #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
     , appendreverse(@toreverse, @sofar) ->
       appendreverse#1(@toreverse, @sofar)
     , appendreverse#1(::(@a, @as), @sofar) ->
       appendreverse(@as, ::(@a, @sofar))
     , appendreverse#1(nil(), @sofar) -> @sofar
     , bfs(@queue, @futurequeue, @x) -> bfs#1(@queue, @futurequeue, @x)
     , bfs#1(::(@t, @ts), @futurequeue, @x) ->
       bfs#3(@t, @futurequeue, @ts, @x)
     , bfs#1(nil(), @futurequeue, @x) -> bfs#2(@futurequeue, @x)
     , bfs#3(leaf(), @futurequeue, @ts, @x) ->
       bfs(@ts, @futurequeue, @x)
     , bfs#3(node(@y, @t1, @t2), @futurequeue, @ts, @x) ->
       bfs#4(#equal(@x, @y), @futurequeue, @t1, @t2, @ts, @x, @y)
     , bfs#2(::(@t, @ts), @x) -> bfs(reverse(::(@t, @ts)), nil(), @x)
     , bfs#2(nil(), @x) -> leaf()
     , reverse(@xs) -> appendreverse(@xs, nil())
     , bfs#4(#false(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
       bfs(@ts, ::(@t2, ::(@t1, @futurequeue)), @x)
     , bfs#4(#true(), @futurequeue, @t1, @t2, @ts, @x, @y) ->
       node(@y, @t1, @t2)
     , bfs2(@t, @x) -> bfs2#1(dobfs(@t, @x), @x)
     , dobfs(@t, @x) -> bfs(::(@t, nil()), nil(), @x)
     , bfs2#1(@t', @x) -> dobfs(@t', @x)
     , dfs(@queue, @x) -> dfs#1(@queue, @x)
     , dfs#1(::(@t, @ts), @x) -> dfs#2(@t, @t, @ts, @x)
     , dfs#1(nil(), @x) -> leaf()
     , dfs#2(leaf(), @t, @ts, @x) -> dfs(@ts, @x)
     , dfs#2(node(@a, @t1, @t2), @t, @ts, @x) ->
       dfs#3(#equal(@a, @x), @t, @t1, @t2, @ts, @x)
     , dfs#3(#false(), @t, @t1, @t2, @ts, @x) ->
       dfs(::(@t1, ::(@t2, @ts)), @x)
     , dfs#3(#true(), @t, @t1, @t2, @ts, @x) -> @t
     , dodfs(@t, @x) -> dfs(::(@t, nil()), @x)
     , #and(#false(), #false()) -> #false()
     , #and(#false(), #true()) -> #false()
     , #and(#true(), #false()) -> #false()
     , #and(#true(), #true()) -> #true() }
   Obligation:
     innermost runtime complexity
   Answer:
     YES(O(1),O(n^1))
   
   We replace rewrite rules by usable rules:
   
     Weak Usable Rules:
       { #equal(@x, @y) -> #eq(@x, @y)
       , #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
         #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
       , #eq(::(@x_1, @x_2), nil()) -> #false()
       , #eq(::(@x_1, @x_2), leaf()) -> #false()
       , #eq(::(@x_1, @x_2), node(@y_1, @y_2, @y_3)) -> #false()
       , #eq(nil(), ::(@y_1, @y_2)) -> #false()
       , #eq(nil(), nil()) -> #true()
       , #eq(nil(), leaf()) -> #false()
       , #eq(nil(), node(@y_1, @y_2, @y_3)) -> #false()
       , #eq(leaf(), ::(@y_1, @y_2)) -> #false()
       , #eq(leaf(), nil()) -> #false()
       , #eq(leaf(), leaf()) -> #true()
       , #eq(leaf(), node(@y_1, @y_2, @y_3)) -> #false()
       , #eq(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2)) -> #false()
       , #eq(node(@x_1, @x_2, @x_3), nil()) -> #false()
       , #eq(node(@x_1, @x_2, @x_3), leaf()) -> #false()
       , #eq(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) ->
         #and(#eq(@x_1, @y_1), #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3)))
       , #eq(#0(), #0()) -> #true()
       , #eq(#0(), #neg(@y)) -> #false()
       , #eq(#0(), #pos(@y)) -> #false()
       , #eq(#0(), #s(@y)) -> #false()
       , #eq(#neg(@x), #0()) -> #false()
       , #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
       , #eq(#neg(@x), #pos(@y)) -> #false()
       , #eq(#pos(@x), #0()) -> #false()
       , #eq(#pos(@x), #neg(@y)) -> #false()
       , #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
       , #eq(#s(@x), #0()) -> #false()
       , #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
       , #and(#false(), #false()) -> #false()
       , #and(#false(), #true()) -> #false()
       , #and(#true(), #false()) -> #false()
       , #and(#true(), #true()) -> #true() }
   
   We are left with following problem, upon which TcT provides the
   certificate YES(O(1),O(n^1)).
   
   Strict DPs:
     { dfs^#(@queue, @x) -> c_14(dfs#1^#(@queue, @x))
     , dfs#1^#(::(@t, @ts), @x) -> c_15(dfs#2^#(@t, @t, @ts, @x))
     , dfs#2^#(leaf(), @t, @ts, @x) -> c_16(dfs^#(@ts, @x))
     , dfs#2^#(node(@a, @t1, @t2), @t, @ts, @x) ->
       c_17(dfs#3^#(#equal(@a, @x), @t, @t1, @t2, @ts, @x))
     , dfs#3^#(#false(), @t, @t1, @t2, @ts, @x) ->
       c_18(dfs^#(::(@t1, ::(@t2, @ts)), @x)) }
   Weak Trs:
     { #equal(@x, @y) -> #eq(@x, @y)
     , #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
       #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
     , #eq(::(@x_1, @x_2), nil()) -> #false()
     , #eq(::(@x_1, @x_2), leaf()) -> #false()
     , #eq(::(@x_1, @x_2), node(@y_1, @y_2, @y_3)) -> #false()
     , #eq(nil(), ::(@y_1, @y_2)) -> #false()
     , #eq(nil(), nil()) -> #true()
     , #eq(nil(), leaf()) -> #false()
     , #eq(nil(), node(@y_1, @y_2, @y_3)) -> #false()
     , #eq(leaf(), ::(@y_1, @y_2)) -> #false()
     , #eq(leaf(), nil()) -> #false()
     , #eq(leaf(), leaf()) -> #true()
     , #eq(leaf(), node(@y_1, @y_2, @y_3)) -> #false()
     , #eq(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2)) -> #false()
     , #eq(node(@x_1, @x_2, @x_3), nil()) -> #false()
     , #eq(node(@x_1, @x_2, @x_3), leaf()) -> #false()
     , #eq(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) ->
       #and(#eq(@x_1, @y_1), #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3)))
     , #eq(#0(), #0()) -> #true()
     , #eq(#0(), #neg(@y)) -> #false()
     , #eq(#0(), #pos(@y)) -> #false()
     , #eq(#0(), #s(@y)) -> #false()
     , #eq(#neg(@x), #0()) -> #false()
     , #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
     , #eq(#neg(@x), #pos(@y)) -> #false()
     , #eq(#pos(@x), #0()) -> #false()
     , #eq(#pos(@x), #neg(@y)) -> #false()
     , #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
     , #eq(#s(@x), #0()) -> #false()
     , #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
     , #and(#false(), #false()) -> #false()
     , #and(#false(), #true()) -> #false()
     , #and(#true(), #false()) -> #false()
     , #and(#true(), #true()) -> #true() }
   Obligation:
     innermost runtime complexity
   Answer:
     YES(O(1),O(n^1))
   
   We use the processor 'matrix interpretation of dimension 1' to
   orient following rules strictly.
   
   DPs:
     { 3: dfs#2^#(leaf(), @t, @ts, @x) -> c_16(dfs^#(@ts, @x)) }
   
   Sub-proof:
   ----------
     The following argument positions are usable:
       Uargs(c_14) = {1}, Uargs(c_15) = {1}, Uargs(c_16) = {1},
       Uargs(c_17) = {1}, Uargs(c_18) = {1}
     
     TcT has computed following constructor-based matrix interpretation
     satisfying not(EDA).
     
                            [#equal](x1, x2) = [0]
                                                  
                               [#eq](x1, x2) = [0]
                                                  
                                [::](x1, x2) = [1] x1 + [1] x2 + [0]
                                                                    
                                       [nil] = [1]
                                                  
                                      [leaf] = [1]
                                                  
                          [node](x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [0]
                                                                             
                                    [#false] = [0]
                                                  
                                     [#true] = [0]
                                                  
                              [#and](x1, x2) = [0]
                                                  
                                        [#0] = [1]
                                                  
                                  [#neg](x1) = [1] x1 + [1]
                                                           
                                  [#pos](x1) = [1] x1 + [1]
                                                           
                                    [#s](x1) = [1] x1 + [1]
                                                           
                          [#equal^#](x1, x2) = [0]
                                                  
                             [#eq^#](x1, x2) = [0]
                                                  
                   [appendreverse^#](x1, x2) = [0]
                                                  
                 [appendreverse#1^#](x1, x2) = [0]
                                                  
                         [bfs^#](x1, x2, x3) = [0]
                                                  
                       [bfs#1^#](x1, x2, x3) = [0]
                                                  
                   [bfs#3^#](x1, x2, x3, x4) = [0]
                                                  
                           [bfs#2^#](x1, x2) = [0]
                                                  
       [bfs#4^#](x1, x2, x3, x4, x5, x6, x7) = [0]
                                                  
                             [reverse^#](x1) = [0]
                                                  
                            [bfs2^#](x1, x2) = [0]
                                                  
                          [bfs2#1^#](x1, x2) = [0]
                                                  
                           [dobfs^#](x1, x2) = [0]
                                                  
                             [dfs^#](x1, x2) = [1] x1 + [0]
                                                           
                           [dfs#1^#](x1, x2) = [1] x1 + [0]
                                                           
                   [dfs#2^#](x1, x2, x3, x4) = [1] x1 + [1] x3 + [0]
                                                                    
           [dfs#3^#](x1, x2, x3, x4, x5, x6) = [1] x3 + [1] x4 + [1] x5 + [0]
                                                                             
                           [dodfs^#](x1, x2) = [0]
                                                  
                            [#and^#](x1, x2) = [0]
                                                  
                                  [c_14](x1) = [1] x1 + [0]
                                                           
                                  [c_15](x1) = [1] x1 + [0]
                                                           
                                  [c_16](x1) = [1] x1 + [0]
                                                           
                                  [c_17](x1) = [1] x1 + [0]
                                                           
                                  [c_18](x1) = [1] x1 + [0]
     
     This order satisfies following ordering constraints
     
                              [dfs^#(@queue, @x)] =  [1] @queue + [0]                                      
                                                  >= [1] @queue + [0]                                      
                                                  =  [c_14(dfs#1^#(@queue, @x))]                           
                                                                                                           
                       [dfs#1^#(::(@t, @ts), @x)] =  [1] @t + [1] @ts + [0]                                
                                                  >= [1] @t + [1] @ts + [0]                                
                                                  =  [c_15(dfs#2^#(@t, @t, @ts, @x))]                      
                                                                                                           
                   [dfs#2^#(leaf(), @t, @ts, @x)] =  [1] @ts + [1]                                         
                                                  >  [1] @ts + [0]                                         
                                                  =  [c_16(dfs^#(@ts, @x))]                                
                                                                                                           
       [dfs#2^#(node(@a, @t1, @t2), @t, @ts, @x)] =  [1] @a + [1] @t1 + [1] @t2 + [1] @ts + [0]            
                                                  >= [1] @t1 + [1] @t2 + [1] @ts + [0]                     
                                                  =  [c_17(dfs#3^#(#equal(@a, @x), @t, @t1, @t2, @ts, @x))]
                                                                                                           
       [dfs#3^#(#false(), @t, @t1, @t2, @ts, @x)] =  [1] @t1 + [1] @t2 + [1] @ts + [0]                     
                                                  >= [1] @t1 + [1] @t2 + [1] @ts + [0]                     
                                                  =  [c_18(dfs^#(::(@t1, ::(@t2, @ts)), @x))]              
                                                                                                           
   
   The strictly oriented rules are moved into the corresponding weak
   component(s).
   
   
   We are left with following problem, upon which TcT provides the
   certificate YES(O(1),O(n^1)).
   
   Strict DPs:
     { dfs^#(@queue, @x) -> c_14(dfs#1^#(@queue, @x))
     , dfs#1^#(::(@t, @ts), @x) -> c_15(dfs#2^#(@t, @t, @ts, @x))
     , dfs#2^#(node(@a, @t1, @t2), @t, @ts, @x) ->
       c_17(dfs#3^#(#equal(@a, @x), @t, @t1, @t2, @ts, @x))
     , dfs#3^#(#false(), @t, @t1, @t2, @ts, @x) ->
       c_18(dfs^#(::(@t1, ::(@t2, @ts)), @x)) }
   Weak DPs: { dfs#2^#(leaf(), @t, @ts, @x) -> c_16(dfs^#(@ts, @x)) }
   Weak Trs:
     { #equal(@x, @y) -> #eq(@x, @y)
     , #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
       #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
     , #eq(::(@x_1, @x_2), nil()) -> #false()
     , #eq(::(@x_1, @x_2), leaf()) -> #false()
     , #eq(::(@x_1, @x_2), node(@y_1, @y_2, @y_3)) -> #false()
     , #eq(nil(), ::(@y_1, @y_2)) -> #false()
     , #eq(nil(), nil()) -> #true()
     , #eq(nil(), leaf()) -> #false()
     , #eq(nil(), node(@y_1, @y_2, @y_3)) -> #false()
     , #eq(leaf(), ::(@y_1, @y_2)) -> #false()
     , #eq(leaf(), nil()) -> #false()
     , #eq(leaf(), leaf()) -> #true()
     , #eq(leaf(), node(@y_1, @y_2, @y_3)) -> #false()
     , #eq(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2)) -> #false()
     , #eq(node(@x_1, @x_2, @x_3), nil()) -> #false()
     , #eq(node(@x_1, @x_2, @x_3), leaf()) -> #false()
     , #eq(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) ->
       #and(#eq(@x_1, @y_1), #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3)))
     , #eq(#0(), #0()) -> #true()
     , #eq(#0(), #neg(@y)) -> #false()
     , #eq(#0(), #pos(@y)) -> #false()
     , #eq(#0(), #s(@y)) -> #false()
     , #eq(#neg(@x), #0()) -> #false()
     , #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
     , #eq(#neg(@x), #pos(@y)) -> #false()
     , #eq(#pos(@x), #0()) -> #false()
     , #eq(#pos(@x), #neg(@y)) -> #false()
     , #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
     , #eq(#s(@x), #0()) -> #false()
     , #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
     , #and(#false(), #false()) -> #false()
     , #and(#false(), #true()) -> #false()
     , #and(#true(), #false()) -> #false()
     , #and(#true(), #true()) -> #true() }
   Obligation:
     innermost runtime complexity
   Answer:
     YES(O(1),O(n^1))
   
   We use the processor 'matrix interpretation of dimension 1' to
   orient following rules strictly.
   
   DPs:
     { 3: dfs#2^#(node(@a, @t1, @t2), @t, @ts, @x) ->
          c_17(dfs#3^#(#equal(@a, @x), @t, @t1, @t2, @ts, @x))
     , 5: dfs#2^#(leaf(), @t, @ts, @x) -> c_16(dfs^#(@ts, @x)) }
   Trs:
     { #eq(nil(), nil()) -> #true()
     , #eq(leaf(), leaf()) -> #true()
     , #eq(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) ->
       #and(#eq(@x_1, @y_1), #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3)))
     , #eq(#0(), #0()) -> #true()
     , #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
     , #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
     , #eq(#s(@x), #s(@y)) -> #eq(@x, @y) }
   
   Sub-proof:
   ----------
     The following argument positions are usable:
       Uargs(c_14) = {1}, Uargs(c_15) = {1}, Uargs(c_16) = {1},
       Uargs(c_17) = {1}, Uargs(c_18) = {1}
     
     TcT has computed following constructor-based matrix interpretation
     satisfying not(EDA).
     
                            [#equal](x1, x2) = [0]
                                                  
                               [#eq](x1, x2) = [1] x1 + [0]
                                                           
                                [::](x1, x2) = [1] x1 + [1] x2 + [0]
                                                                    
                                       [nil] = [1]
                                                  
                                      [leaf] = [1]
                                                  
                          [node](x1, x2, x3) = [1] x1 + [1] x2 + [1] x3 + [1]
                                                                             
                                    [#false] = [1]
                                                  
                                     [#true] = [0]
                                                  
                              [#and](x1, x2) = [0]
                                                  
                                        [#0] = [1]
                                                  
                                  [#neg](x1) = [1] x1 + [1]
                                                           
                                  [#pos](x1) = [1] x1 + [1]
                                                           
                                    [#s](x1) = [1] x1 + [1]
                                                           
                          [#equal^#](x1, x2) = [0]
                                                  
                             [#eq^#](x1, x2) = [0]
                                                  
                   [appendreverse^#](x1, x2) = [0]
                                                  
                 [appendreverse#1^#](x1, x2) = [0]
                                                  
                         [bfs^#](x1, x2, x3) = [0]
                                                  
                       [bfs#1^#](x1, x2, x3) = [0]
                                                  
                   [bfs#3^#](x1, x2, x3, x4) = [0]
                                                  
                           [bfs#2^#](x1, x2) = [0]
                                                  
       [bfs#4^#](x1, x2, x3, x4, x5, x6, x7) = [0]
                                                  
                             [reverse^#](x1) = [0]
                                                  
                            [bfs2^#](x1, x2) = [0]
                                                  
                          [bfs2#1^#](x1, x2) = [0]
                                                  
                           [dobfs^#](x1, x2) = [0]
                                                  
                             [dfs^#](x1, x2) = [1] x1 + [0]
                                                           
                           [dfs#1^#](x1, x2) = [1] x1 + [0]
                                                           
                   [dfs#2^#](x1, x2, x3, x4) = [1] x1 + [1] x3 + [0]
                                                                    
           [dfs#3^#](x1, x2, x3, x4, x5, x6) = [1] x3 + [1] x4 + [1] x5 + [0]
                                                                             
                           [dodfs^#](x1, x2) = [0]
                                                  
                            [#and^#](x1, x2) = [0]
                                                  
                                  [c_14](x1) = [1] x1 + [0]
                                                           
                                  [c_15](x1) = [1] x1 + [0]
                                                           
                                  [c_16](x1) = [1] x1 + [0]
                                                           
                                  [c_17](x1) = [1] x1 + [0]
                                                           
                                  [c_18](x1) = [1] x1 + [0]
     
     This order satisfies following ordering constraints
     
                              [dfs^#(@queue, @x)] =  [1] @queue + [0]                                      
                                                  >= [1] @queue + [0]                                      
                                                  =  [c_14(dfs#1^#(@queue, @x))]                           
                                                                                                           
                       [dfs#1^#(::(@t, @ts), @x)] =  [1] @t + [1] @ts + [0]                                
                                                  >= [1] @t + [1] @ts + [0]                                
                                                  =  [c_15(dfs#2^#(@t, @t, @ts, @x))]                      
                                                                                                           
                   [dfs#2^#(leaf(), @t, @ts, @x)] =  [1] @ts + [1]                                         
                                                  >  [1] @ts + [0]                                         
                                                  =  [c_16(dfs^#(@ts, @x))]                                
                                                                                                           
       [dfs#2^#(node(@a, @t1, @t2), @t, @ts, @x)] =  [1] @a + [1] @t1 + [1] @t2 + [1] @ts + [1]            
                                                  >  [1] @t1 + [1] @t2 + [1] @ts + [0]                     
                                                  =  [c_17(dfs#3^#(#equal(@a, @x), @t, @t1, @t2, @ts, @x))]
                                                                                                           
       [dfs#3^#(#false(), @t, @t1, @t2, @ts, @x)] =  [1] @t1 + [1] @t2 + [1] @ts + [0]                     
                                                  >= [1] @t1 + [1] @t2 + [1] @ts + [0]                     
                                                  =  [c_18(dfs^#(::(@t1, ::(@t2, @ts)), @x))]              
                                                                                                           
   
   Consider the set of all dependency pairs
   
   DPs:
     { 1: dfs^#(@queue, @x) -> c_14(dfs#1^#(@queue, @x))
     , 2: dfs#1^#(::(@t, @ts), @x) -> c_15(dfs#2^#(@t, @t, @ts, @x))
     , 3: dfs#2^#(node(@a, @t1, @t2), @t, @ts, @x) ->
          c_17(dfs#3^#(#equal(@a, @x), @t, @t1, @t2, @ts, @x))
     , 4: dfs#3^#(#false(), @t, @t1, @t2, @ts, @x) ->
          c_18(dfs^#(::(@t1, ::(@t2, @ts)), @x))
     , 5: dfs#2^#(leaf(), @t, @ts, @x) -> c_16(dfs^#(@ts, @x)) }
   
   Processor 'matrix interpretation of dimension 1' induces the
   complexity certificate YES(?,O(n^1)) on application of dependency
   pairs {3,5}. These cover all (indirect) predecessors of dependency
   pairs {1,2,3,4,5}, their number of application is equally bounded.
   The dependency pairs are shifted into the corresponding weak
   component(s).
   
   We apply the transformation 'removetails' on the sub-problem:
   
   Weak DPs:
     { dfs^#(@queue, @x) -> c_14(dfs#1^#(@queue, @x))
     , dfs#1^#(::(@t, @ts), @x) -> c_15(dfs#2^#(@t, @t, @ts, @x))
     , dfs#2^#(leaf(), @t, @ts, @x) -> c_16(dfs^#(@ts, @x))
     , dfs#2^#(node(@a, @t1, @t2), @t, @ts, @x) ->
       c_17(dfs#3^#(#equal(@a, @x), @t, @t1, @t2, @ts, @x))
     , dfs#3^#(#false(), @t, @t1, @t2, @ts, @x) ->
       c_18(dfs^#(::(@t1, ::(@t2, @ts)), @x)) }
   Weak Trs:
     { #equal(@x, @y) -> #eq(@x, @y)
     , #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
       #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
     , #eq(::(@x_1, @x_2), nil()) -> #false()
     , #eq(::(@x_1, @x_2), leaf()) -> #false()
     , #eq(::(@x_1, @x_2), node(@y_1, @y_2, @y_3)) -> #false()
     , #eq(nil(), ::(@y_1, @y_2)) -> #false()
     , #eq(nil(), nil()) -> #true()
     , #eq(nil(), leaf()) -> #false()
     , #eq(nil(), node(@y_1, @y_2, @y_3)) -> #false()
     , #eq(leaf(), ::(@y_1, @y_2)) -> #false()
     , #eq(leaf(), nil()) -> #false()
     , #eq(leaf(), leaf()) -> #true()
     , #eq(leaf(), node(@y_1, @y_2, @y_3)) -> #false()
     , #eq(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2)) -> #false()
     , #eq(node(@x_1, @x_2, @x_3), nil()) -> #false()
     , #eq(node(@x_1, @x_2, @x_3), leaf()) -> #false()
     , #eq(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) ->
       #and(#eq(@x_1, @y_1), #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3)))
     , #eq(#0(), #0()) -> #true()
     , #eq(#0(), #neg(@y)) -> #false()
     , #eq(#0(), #pos(@y)) -> #false()
     , #eq(#0(), #s(@y)) -> #false()
     , #eq(#neg(@x), #0()) -> #false()
     , #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
     , #eq(#neg(@x), #pos(@y)) -> #false()
     , #eq(#pos(@x), #0()) -> #false()
     , #eq(#pos(@x), #neg(@y)) -> #false()
     , #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
     , #eq(#s(@x), #0()) -> #false()
     , #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
     , #and(#false(), #false()) -> #false()
     , #and(#false(), #true()) -> #false()
     , #and(#true(), #false()) -> #false()
     , #and(#true(), #true()) -> #true() }
   StartTerms: basic terms
   Strategy: innermost
   
   The following weak DPs constitute a sub-graph of the DG that is
   closed under successors. The DPs are removed.
   
   { dfs^#(@queue, @x) -> c_14(dfs#1^#(@queue, @x))
   , dfs#1^#(::(@t, @ts), @x) -> c_15(dfs#2^#(@t, @t, @ts, @x))
   , dfs#2^#(leaf(), @t, @ts, @x) -> c_16(dfs^#(@ts, @x))
   , dfs#2^#(node(@a, @t1, @t2), @t, @ts, @x) ->
     c_17(dfs#3^#(#equal(@a, @x), @t, @t1, @t2, @ts, @x))
   , dfs#3^#(#false(), @t, @t1, @t2, @ts, @x) ->
     c_18(dfs^#(::(@t1, ::(@t2, @ts)), @x)) }
   
   
   We apply the transformation 'usablerules' on the sub-problem:
   
   Weak Trs:
     { #equal(@x, @y) -> #eq(@x, @y)
     , #eq(::(@x_1, @x_2), ::(@y_1, @y_2)) ->
       #and(#eq(@x_1, @y_1), #eq(@x_2, @y_2))
     , #eq(::(@x_1, @x_2), nil()) -> #false()
     , #eq(::(@x_1, @x_2), leaf()) -> #false()
     , #eq(::(@x_1, @x_2), node(@y_1, @y_2, @y_3)) -> #false()
     , #eq(nil(), ::(@y_1, @y_2)) -> #false()
     , #eq(nil(), nil()) -> #true()
     , #eq(nil(), leaf()) -> #false()
     , #eq(nil(), node(@y_1, @y_2, @y_3)) -> #false()
     , #eq(leaf(), ::(@y_1, @y_2)) -> #false()
     , #eq(leaf(), nil()) -> #false()
     , #eq(leaf(), leaf()) -> #true()
     , #eq(leaf(), node(@y_1, @y_2, @y_3)) -> #false()
     , #eq(node(@x_1, @x_2, @x_3), ::(@y_1, @y_2)) -> #false()
     , #eq(node(@x_1, @x_2, @x_3), nil()) -> #false()
     , #eq(node(@x_1, @x_2, @x_3), leaf()) -> #false()
     , #eq(node(@x_1, @x_2, @x_3), node(@y_1, @y_2, @y_3)) ->
       #and(#eq(@x_1, @y_1), #and(#eq(@x_2, @y_2), #eq(@x_3, @y_3)))
     , #eq(#0(), #0()) -> #true()
     , #eq(#0(), #neg(@y)) -> #false()
     , #eq(#0(), #pos(@y)) -> #false()
     , #eq(#0(), #s(@y)) -> #false()
     , #eq(#neg(@x), #0()) -> #false()
     , #eq(#neg(@x), #neg(@y)) -> #eq(@x, @y)
     , #eq(#neg(@x), #pos(@y)) -> #false()
     , #eq(#pos(@x), #0()) -> #false()
     , #eq(#pos(@x), #neg(@y)) -> #false()
     , #eq(#pos(@x), #pos(@y)) -> #eq(@x, @y)
     , #eq(#s(@x), #0()) -> #false()
     , #eq(#s(@x), #s(@y)) -> #eq(@x, @y)
     , #and(#false(), #false()) -> #false()
     , #and(#false(), #true()) -> #false()
     , #and(#true(), #false()) -> #false()
     , #and(#true(), #true()) -> #true() }
   StartTerms: basic terms
   Strategy: innermost
   
   No rule is usable, rules are removed from the input problem.
   
   
   We are left with following problem, upon which TcT provides the
   certificate YES(O(1),O(1)).
   
   Rules: Empty
   Obligation:
     innermost runtime complexity
   Answer:
     YES(O(1),O(1))
   
   Empty rules are trivially bounded
   
   Wall-time: 0.923161s
   CPU-time: 8.993s


Hurray, we answered YES(O(1),O(n^2))